Merge branch 'dev' into update-readme

.coderabbit.yaml

@@ -0,0 +1,25 @@
+# yaml-language-server: $schema=https://coderabbit.ai/integrations/schema.v2.json
+language: "en"
+early_access: false
+knowledge_base:
+  learnings:
+    scope: auto
+  issues:
+    scope: global
+reviews:
+  profile: "chill"
+  request_changes_workflow: false
+  high_level_summary: true
+  poem: false
+  review_status: true
+  collapse_walkthrough: true
+  auto_review:
+    enabled: true
+    ignore_title_keywords:
+      - "WIP"
+      - "DO NOT MERGE"
+    drafts: false
+    base_branches:
+      - dev
+chat:
+  auto_reply: true

.github/actions/upload-coverage/action.yml

@@ -15,15 +15,15 @@ runs:
     # This method has the limitation of 1 coverage file per run, limiting some coverage between online/offline tests.
     - run: |
         COVERAGE_UUID=$(python3 -c "import uuid; print(uuid.uuid4())")
-        echo "COVERAGE_UUID=${COVERAGE_UUID}" >> $GITHUB_OUTPUT
+        echo "COVERAGE_UUID=${COVERAGE_UUID}" >> "$GITHUB_OUTPUT"
         if [ -f .coverage ]; then
           mv .coverage .coverage.${COVERAGE_UUID}
         fi
       id: coverage-uuid
       shell: bash
-    - uses: actions/upload-artifact@v3.1.0
+    - uses: actions/upload-artifact@v4
       with:
-        name: coverage-data
+        name: coverage-data-${{ steps.coverage-uuid.outputs.COVERAGE_UUID }}
         path: |
           .coverage.*
           *.lcov

.github/workflows/black.yml

@@ -32,7 +32,7 @@ jobs:
           fetch-depth: 0
 
       - name: Set up Python 3.8
-        uses: actions/setup-python@v4
+        uses: actions/setup-python@v5
         with:
           python-version: 3.8
 

.github/workflows/ci.yml

@@ -26,7 +26,7 @@ jobs:
       fail-fast: false
       matrix:
         os: ["ubuntu-latest", "windows-2022"]
-        python: ${{ (github.event_name == 'pull_request' && fromJSON('["3.8", "3.11"]')) || fromJSON('["3.8", "3.9", "3.10", "3.11"]') }}
+        python: ${{ (github.event_name == 'pull_request' && fromJSON('["3.8", "3.12"]')) || fromJSON('["3.8", "3.9", "3.10", "3.11", "3.12"]') }}
         type: ["cli",
                "dapp",
                "data_dependency",
@@ -55,7 +55,7 @@ jobs:
     steps:
       - uses: actions/checkout@v4
       - name: Set up Python ${{ matrix.python }}
-        uses: actions/setup-python@v4
+        uses: actions/setup-python@v5
         with:
           python-version: ${{ matrix.python }}
       - name: Install dependencies
@@ -67,11 +67,11 @@ jobs:
 
       - name: Set up nix
         if: matrix.type == 'dapp'
-        uses: cachix/install-nix-action@v23
+        uses: cachix/install-nix-action@V27
 
       - name: Set up cachix
         if: matrix.type == 'dapp'
-        uses: cachix/cachix-action@v12
+        uses: cachix/cachix-action@v15
         with:
           name: dapp
 

.github/workflows/docker.yml

@@ -30,7 +30,7 @@ jobs:
 
       - name: Set Docker metadata
         id: metadata
-        uses: docker/metadata-action@v4
+        uses: docker/metadata-action@v5
         with:
           images: |
             ghcr.io/${{ github.repository }}

.github/workflows/docs.yml

@@ -30,17 +30,17 @@ jobs:
       - name: Checkout
         uses: actions/checkout@v4
       - name: Setup Pages
-        uses: actions/configure-pages@v3
-      - uses: actions/setup-python@v4
+        uses: actions/configure-pages@v5
+      - uses: actions/setup-python@v5
         with:
           python-version: '3.8'
       - run: pip install -e ".[doc]"
       - run: pdoc -o html/ slither '!slither.tools' #TODO fix import errors on pdoc run
       - name: Upload artifact
-        uses: actions/upload-pages-artifact@v2
+        uses: actions/upload-pages-artifact@v3
         with:
           # Upload the doc
           path: './html/'
       - name: Deploy to GitHub Pages
         id: deployment
-        uses: actions/deploy-pages@v2
+        uses: actions/deploy-pages@v4

.github/workflows/doctor.yml

@@ -23,7 +23,7 @@ jobs:
       fail-fast: false
       matrix:
         os: ["ubuntu-latest", "windows-2022"]
-        python: ["3.8", "3.9", "3.10", "3.11"]
+        python: ["3.8", "3.9", "3.10", "3.11", "3.12"]
         exclude:
           # strange failure
           - os: windows-2022
@@ -32,7 +32,7 @@ jobs:
       - uses: actions/checkout@v4
 
       - name: Set up Python ${{ matrix.python }}
-        uses: actions/setup-python@v4
+        uses: actions/setup-python@v5
         with:
           python-version: ${{ matrix.python }}
 

.github/workflows/issue-metrics.yml

@@ -0,0 +1,40 @@
+name: Monthly issue metrics
+on:
+  workflow_dispatch:
+  schedule:
+    - cron: '3 2 1 * *'
+
+permissions:
+  issues: write
+  pull-requests: read
+
+jobs:
+  build:
+    name: issue metrics
+    runs-on: ubuntu-latest
+    steps:
+    - name: Get dates for last month
+      shell: bash
+      run: |
+        # Calculate the first day of the previous month
+        first_day=$(date -d "last month" +%Y-%m-01)
+
+        # Calculate the last day of the previous month
+        last_day=$(date -d "$first_day +1 month -1 day" +%Y-%m-%d)
+
+        #Set an environment variable with the date range
+        echo "$first_day..$last_day"
+        echo "last_month=$first_day..$last_day" >> "$GITHUB_ENV"
+
+    - name: Run issue-metrics tool
+      uses: github/issue-metrics@v3
+      env:
+        GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        SEARCH_QUERY: 'repo:crytic/slither is:issue created:${{ env.last_month }} -reason:"not planned" -reason:"duplicate"'
+
+    - name: Create issue
+      uses: peter-evans/create-issue-from-file@v5
+      with:
+        title: Monthly issue metrics report
+        token: ${{ secrets.GITHUB_TOKEN }}
+        content-filepath: ./issue_metrics.md

.github/workflows/linter.yml

@@ -31,7 +31,7 @@ jobs:
           fetch-depth: 0
 
       - name: Set up Python 3.8
-        uses: actions/setup-python@v4
+        uses: actions/setup-python@v5
         with:
           python-version: 3.8
 
@@ -45,7 +45,7 @@ jobs:
           echo "::add-matcher::.github/workflows/matchers/yamllint.json"
 
       - name: Lint everything else
-        uses: super-linter/super-linter/slim@v4.9.2
+        uses: super-linter/super-linter/slim@v6.1.1
         if: always()
         env:
           # run linter on everything to catch preexisting problems
@@ -58,6 +58,7 @@ jobs:
           VALIDATE_PYTHON_BLACK: false
           VALIDATE_PYTHON_ISORT: false
           VALIDATE_JSON: false
+          VALIDATE_JAVASCRIPT_ES: false
           VALIDATE_JAVASCRIPT_STANDARD: false
           VALIDATE_PYTHON_FLAKE8: false
           VALIDATE_DOCKERFILE: false
@@ -65,7 +66,8 @@ jobs:
           VALIDATE_EDITORCONFIG: false
           VALIDATE_JSCPD: false
           VALIDATE_PYTHON_MYPY: false
-          # Until we upgrade the super linter for actionlintÒ
-          VALIDATE_GITHUB_ACTIONS: false
+          VALIDATE_CHECKOV: false
+          # TODO: consider enabling
+          VALIDATE_SHELL_SHFMT: false
           SHELLCHECK_OPTS: "-e SC1090"
           FILTER_REGEX_EXCLUDE: .*tests/.*.(json|zip|sol)

.github/workflows/pip-audit.yml

@@ -21,7 +21,7 @@ jobs:
         uses: actions/checkout@v4
 
       - name: Install Python
-        uses: actions/setup-python@v4
+        uses: actions/setup-python@v5
         with:
           python-version: "3.10"
 

.github/workflows/publish.yml

@@ -13,7 +13,7 @@ jobs:
       - uses: actions/checkout@v4
 
       - name: Set up Python
-        uses: actions/setup-python@v4
+        uses: actions/setup-python@v5
         with:
           python-version: '3.x'
 
@@ -23,7 +23,7 @@ jobs:
           python -m pip install build
           python -m build
       - name: Upload distributions
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
         with:
           name: slither-dists
           path: dist/
@@ -38,16 +38,16 @@ jobs:
       - build-release
     steps:
       - name: fetch dists
-        uses: actions/download-artifact@v3
+        uses: actions/download-artifact@v4
         with:
           name: slither-dists
           path: dist/
 
       - name: publish
-        uses: pypa/gh-action-pypi-publish@v1.8.10
+        uses: pypa/gh-action-pypi-publish@v1.8.14
 
       - name: sign
-        uses: sigstore/gh-action-sigstore-python@v2.1.0
+        uses: sigstore/gh-action-sigstore-python@v2.1.1
         with:
           inputs: ./dist/*.tar.gz ./dist/*.whl
           release-signing-artifacts: true

.github/workflows/pylint.yml

@@ -29,7 +29,7 @@ jobs:
           fetch-depth: 0
 
       - name: Set up Python 3.8
-        uses: actions/setup-python@v4
+        uses: actions/setup-python@v5
         with:
           python-version: 3.8
 
@@ -43,7 +43,7 @@ jobs:
           echo "::add-matcher::.github/workflows/matchers/pylint.json"
 
       - name: Pylint
-        uses: super-linter/super-linter/slim@v4.9.2
+        uses: super-linter/super-linter/slim@v6.1.1
         if: always()
         env:
           # Run linters only on new files for pylint to speed up the CI

.github/workflows/test.yml

@@ -25,11 +25,11 @@ jobs:
       matrix:
         os: ["ubuntu-latest", "windows-2022"]
         type: ["unit", "integration", "tool"]
-        python: ${{ (github.event_name == 'pull_request' && fromJSON('["3.8", "3.11"]')) || fromJSON('["3.8", "3.9", "3.10", "3.11"]') }}
+        python: ${{ (github.event_name == 'pull_request' && fromJSON('["3.8", "3.12"]')) || fromJSON('["3.8", "3.9", "3.10", "3.11", "3.12"]') }}
     steps:
       - uses: actions/checkout@v4
       - name: Set up Python ${{ matrix.python }}
-        uses: actions/setup-python@v4
+        uses: actions/setup-python@v5
         with:
           python-version: ${{ matrix.python }}
           cache: "pip"
@@ -40,7 +40,7 @@ jobs:
           pip install ".[test]"
 
       - name: Setup node
-        uses: actions/setup-node@v3
+        uses: actions/setup-node@v4
         with:
           node-version: '16'
           cache: 'npm'
@@ -80,11 +80,11 @@ jobs:
         # Only run coverage on ubuntu-latest.
         run: |
           if [ ${{ matrix.os }} = "ubuntu-latest" ]; then
-            TEST_ARGS="--cov=slither --cov-append"
+            TEST_ARGS=(--cov=slither --cov-append)
           elif [ ${{ matrix.os }} = "windows-2022" ]; then
-            TEST_ARGS=""
+            TEST_ARGS=()
           fi
-          bash "./.github/scripts/${TEST_TYPE}_test_runner.sh" $TEST_ARGS
+          bash "./.github/scripts/${TEST_TYPE}_test_runner.sh" "${TEST_ARGS[@]}"
 
 
       - name: Upload coverage
@@ -102,21 +102,22 @@ jobs:
     steps:
       - uses: actions/checkout@v4
       - name: Set up Python 3.8
-        uses: actions/setup-python@v4
+        uses: actions/setup-python@v5
         with:
           python-version: 3.8
 
       - run: pip install coverage[toml]
 
       - name: download coverage data
-        uses: actions/download-artifact@v3.0.2
+        uses: actions/download-artifact@v4
         with:
-          name: coverage-data
+          pattern: coverage-data-*
+          merge-multiple: true
 
       - name: combine coverage data
         id: combinecoverage
         run: |
           set +e
           python -m coverage combine
-          echo "## python coverage" >> $GITHUB_STEP_SUMMARY
-          python -m coverage report -m --format=markdown >> $GITHUB_STEP_SUMMARY
+          echo "## python coverage" >> "$GITHUB_STEP_SUMMARY"
+          python -m coverage report -m --format=markdown >> "$GITHUB_STEP_SUMMARY"

CONTRIBUTING.md

@@ -6,7 +6,7 @@ If you're unsure where to start, we recommend our [`good first issue`](https://g
 
 ## Bug reports and feature suggestions
 
-Bug reports and feature suggestions can be submitted to our issue tracker. For bug reports, attaching the contract that caused the bug will help us in debugging and resolving the issue quickly. If you find a security vulnerability, do not open an issue; email opensource@trailofbits.com instead.
+Bug reports and feature suggestions can be submitted to our issue tracker. For bug reports, attaching the contract that caused the bug will help us in debugging and resolving the issue quickly. If you find a security vulnerability, do not open an issue; email <opensource@trailofbits.com> instead.
 
 ## Questions
 
@@ -14,7 +14,7 @@ Questions can be submitted to the "Discussions" page, and you may also join our
 
 ## Code
 
-Slither uses the pull request contribution model. Please make an account on Github, fork this repo, and submit code contributions via pull request. For more documentation, look [here](https://guides.github.com/activities/forking/).
+Slither uses the pull request contribution model. Please make an account on GitHub, fork this repository, and submit code contributions via pull request. For more documentation, look [here](https://guides.github.com/activities/forking/).
 
 Some pull request guidelines:
 
@@ -63,7 +63,7 @@ To automatically reformat the code:
 
 - `make reformat`
 
-We use pylint `2.13.4`, black `22.3.0`.
+We use pylint `3.0.3`, black `22.3.0`.
 
 ### Testing
 
@@ -82,7 +82,7 @@ For each new detector, at least one regression tests must be present.
 1. Create a folder in `tests/e2e/detectors/test_data` with the detector's argument name.
 2. Create a test contract in `tests/e2e/detectors/test_data/<detector_name>/`.
 3. Update `ALL_TESTS` in `tests/e2e/detectors/test_detectors.py`.
-4. Run `python tests/e2e/detectors/test_detectors.py --compile` to create a zip file of the compilation artifacts.
+4. Run `python tests/e2e/detectors/test_detectors.py --compile` to create a ZIP file of the compilation artifacts.
 5. `pytest tests/e2e/detectors/test_detectors.py --insta update-new`. This will generate a snapshot of the detector output in `tests/e2e/detectors/snapshots/`. If updating an existing detector, run `pytest tests/e2e/detectors/test_detectors.py --insta review` and accept or reject the updates.
 6. Run `pytest tests/e2e/detectors/test_detectors.py` to ensure everything worked. Then, add and commit the files to git.
 

Dockerfile

@@ -47,6 +47,6 @@ ENV PATH="/home/slither/.local/bin:${PATH}"
 RUN --mount=type=bind,target=/mnt,source=/wheels,from=python-wheels \
     pip3 install --user --no-cache-dir --upgrade --no-index --find-links /mnt --no-deps /mnt/*.whl
 
-RUN solc-select install 0.4.25 && solc-select use 0.4.25
+RUN solc-select use latest --always-install
 
 CMD /bin/bash

FUNDING.json

@@ -0,0 +1,7 @@
+{
+    "Optimism": {
+        "op-mainnet": {
+            "ownedBy": "0xc44F30Be3eBBEfdDBB5a85168710b4f0e18f4Ff0"
+        }
+    }
+}

README.md

@@ -7,7 +7,7 @@
 [![Slither - Read the Docs](https://img.shields.io/badge/Slither-Read_the_Docs-2ea44f)](https://crytic.github.io/slither/slither.html)
 [![Slither - Wiki](https://img.shields.io/badge/Slither-Wiki-2ea44f)](https://github.com/crytic/slither/wiki/SlithIR)
 
-> Join the Empire Hacking Slack  
+> Join the Empire Hacking Slack
 >
 > [![Slack Status](https://slack.empirehacking.nyc/badge.svg)](https://slack.empirehacking.nyc/)
 > > <sub><i>- Discussions and Support </i></sub>
@@ -46,7 +46,7 @@
 * Correctly parses 99.9% of all public Solidity code
 * Average execution time of less than 1 second per contract
 * Integrates with Github's code scanning in [CI](https://github.com/marketplace/actions/slither-action)
-* Support for Vyper
+* Support for Vyper smart contracts
 
 ## Usage
 
@@ -73,14 +73,14 @@ If you're **not** going to use one of the [supported compilation frameworks](htt
 ### Using Pip
 
 ```console
-pip3 install slither-analyzer
+python3 -m pip install slither-analyzer
 ```
 
 ### Using Git
 
 ```bash
 git clone https://github.com/crytic/slither.git && cd slither
-python3 setup.py install
+python3 -m pip install .
 ```
 
 We recommend using a Python virtual environment, as detailed in the [Developer Installation Instructions](https://github.com/trailofbits/slither/wiki/Developer-installation), if you prefer to install Slither via git.
@@ -131,10 +131,10 @@ Num | Detector | What it Detects | Impact | Confidence
 20 | `controlled-delegatecall` | [Controlled delegatecall destination](https://github.com/crytic/slither/wiki/Detector-Documentation#controlled-delegatecall) | High | Medium
 21 | `delegatecall-loop` | [Payable functions using `delegatecall` inside a loop](https://github.com/crytic/slither/wiki/Detector-Documentation/#payable-functions-using-delegatecall-inside-a-loop) | High | Medium
 22 | `incorrect-exp` | [Incorrect exponentiation](https://github.com/crytic/slither/wiki/Detector-Documentation#incorrect-exponentiation) | High | Medium
-23 | `incorrect-return` | [If a `return` is incorrectly used in assembly mode.](https://github.com/crytic/slither/wiki/Detector-Documentation#incorrect-assembly-return) | High | Medium
+23 | `incorrect-return` | [If a `return` is incorrectly used in assembly mode.](https://github.com/crytic/slither/wiki/Detector-Documentation#incorrect-return-in-assembly) | High | Medium
 24 | `msg-value-loop` | [msg.value inside a loop](https://github.com/crytic/slither/wiki/Detector-Documentation/#msgvalue-inside-a-loop) | High | Medium
 25 | `reentrancy-eth` | [Reentrancy vulnerabilities (theft of ethers)](https://github.com/crytic/slither/wiki/Detector-Documentation#reentrancy-vulnerabilities) | High | Medium
-26 | `return-leave` | [If a `return` is used instead of a `leave`.](https://github.com/crytic/slither/wiki/Detector-Documentation#incorrect-assembly-return) | High | Medium
+26 | `return-leave` | [If a `return` is used instead of a `leave`.](https://github.com/crytic/slither/wiki/Detector-Documentation#return-instead-of-leave-in-assembly) | High | Medium
 27 | `storage-array` | [Signed storage integer array compiler bug](https://github.com/crytic/slither/wiki/Detector-Documentation#storage-signed-integer-array) | High | Medium
 28 | `unchecked-transfer` | [Unchecked tokens transfer](https://github.com/crytic/slither/wiki/Detector-Documentation#unchecked-transfer) | High | Medium
 29 | `weak-prng` | [Weak PRNG](https://github.com/crytic/slither/wiki/Detector-Documentation#weak-PRNG) | High | Medium
@@ -153,54 +153,56 @@ Num | Detector | What it Detects | Impact | Confidence
 42 | `constant-function-asm` | [Constant functions using assembly code](https://github.com/crytic/slither/wiki/Detector-Documentation#constant-functions-using-assembly-code) | Medium | Medium
 43 | `constant-function-state` | [Constant functions changing the state](https://github.com/crytic/slither/wiki/Detector-Documentation#constant-functions-changing-the-state) | Medium | Medium
 44 | `divide-before-multiply` | [Imprecise arithmetic operations order](https://github.com/crytic/slither/wiki/Detector-Documentation#divide-before-multiply) | Medium | Medium
-45 | `reentrancy-no-eth` | [Reentrancy vulnerabilities (no theft of ethers)](https://github.com/crytic/slither/wiki/Detector-Documentation#reentrancy-vulnerabilities-1) | Medium | Medium
-46 | `reused-constructor` | [Reused base constructor](https://github.com/crytic/slither/wiki/Detector-Documentation#reused-base-constructors) | Medium | Medium
-47 | `tx-origin` | [Dangerous usage of `tx.origin`](https://github.com/crytic/slither/wiki/Detector-Documentation#dangerous-usage-of-txorigin) | Medium | Medium
-48 | `unchecked-lowlevel` | [Unchecked low-level calls](https://github.com/crytic/slither/wiki/Detector-Documentation#unchecked-low-level-calls) | Medium | Medium
-49 | `unchecked-send` | [Unchecked send](https://github.com/crytic/slither/wiki/Detector-Documentation#unchecked-send) | Medium | Medium
-50 | `uninitialized-local` | [Uninitialized local variables](https://github.com/crytic/slither/wiki/Detector-Documentation#uninitialized-local-variables) | Medium | Medium
-51 | `unused-return` | [Unused return values](https://github.com/crytic/slither/wiki/Detector-Documentation#unused-return) | Medium | Medium
-52 | `incorrect-modifier` | [Modifiers that can return the default value](https://github.com/crytic/slither/wiki/Detector-Documentation#incorrect-modifier) | Low | High
-53 | `shadowing-builtin` | [Built-in symbol shadowing](https://github.com/crytic/slither/wiki/Detector-Documentation#builtin-symbol-shadowing) | Low | High
-54 | `shadowing-local` | [Local variables shadowing](https://github.com/crytic/slither/wiki/Detector-Documentation#local-variable-shadowing) | Low | High
-55 | `uninitialized-fptr-cst` | [Uninitialized function pointer calls in constructors](https://github.com/crytic/slither/wiki/Detector-Documentation#uninitialized-function-pointers-in-constructors) | Low | High
-56 | `variable-scope` | [Local variables used prior their declaration](https://github.com/crytic/slither/wiki/Detector-Documentation#pre-declaration-usage-of-local-variables) | Low | High
-57 | `void-cst` | [Constructor called not implemented](https://github.com/crytic/slither/wiki/Detector-Documentation#void-constructor) | Low | High
-58 | `calls-loop` | [Multiple calls in a loop](https://github.com/crytic/slither/wiki/Detector-Documentation/#calls-inside-a-loop) | Low | Medium
-59 | `events-access` | [Missing Events Access Control](https://github.com/crytic/slither/wiki/Detector-Documentation#missing-events-access-control) | Low | Medium
-60 | `events-maths` | [Missing Events Arithmetic](https://github.com/crytic/slither/wiki/Detector-Documentation#missing-events-arithmetic) | Low | Medium
-61 | `incorrect-unary` | [Dangerous unary expressions](https://github.com/crytic/slither/wiki/Detector-Documentation#dangerous-unary-expressions) | Low | Medium
-62 | `missing-zero-check` | [Missing Zero Address Validation](https://github.com/crytic/slither/wiki/Detector-Documentation#missing-zero-address-validation) | Low | Medium
-63 | `reentrancy-benign` | [Benign reentrancy vulnerabilities](https://github.com/crytic/slither/wiki/Detector-Documentation#reentrancy-vulnerabilities-2) | Low | Medium
-64 | `reentrancy-events` | [Reentrancy vulnerabilities leading to out-of-order Events](https://github.com/crytic/slither/wiki/Detector-Documentation#reentrancy-vulnerabilities-3) | Low | Medium
-65 | `return-bomb` | [A low level callee may consume all callers gas unexpectedly.](https://github.com/crytic/slither/wiki/Detector-Documentation#return-bomb) | Low | Medium
-66 | `timestamp` | [Dangerous usage of `block.timestamp`](https://github.com/crytic/slither/wiki/Detector-Documentation#block-timestamp) | Low | Medium
-67 | `assembly` | [Assembly usage](https://github.com/crytic/slither/wiki/Detector-Documentation#assembly-usage) | Informational | High
-68 | `assert-state-change` | [Assert state change](https://github.com/crytic/slither/wiki/Detector-Documentation#assert-state-change) | Informational | High
-69 | `boolean-equal` | [Comparison to boolean constant](https://github.com/crytic/slither/wiki/Detector-Documentation#boolean-equality) | Informational | High
-70 | `cyclomatic-complexity` | [Detects functions with high (> 11) cyclomatic complexity](https://github.com/crytic/slither/wiki/Detector-Documentation#cyclomatic-complexity) | Informational | High
-71 | `deprecated-standards` | [Deprecated Solidity Standards](https://github.com/crytic/slither/wiki/Detector-Documentation#deprecated-standards) | Informational | High
-72 | `erc20-indexed` | [Un-indexed ERC20 event parameters](https://github.com/crytic/slither/wiki/Detector-Documentation#unindexed-erc20-event-parameters) | Informational | High
-73 | `function-init-state` | [Function initializing state variables](https://github.com/crytic/slither/wiki/Detector-Documentation#function-initializing-state) | Informational | High
-74 | `incorrect-using-for` | [Detects using-for statement usage when no function from a given library matches a given type](https://github.com/crytic/slither/wiki/Detector-Documentation#incorrect-using-for-usage) | Informational | High
-75 | `low-level-calls` | [Low level calls](https://github.com/crytic/slither/wiki/Detector-Documentation#low-level-calls) | Informational | High
-76 | `missing-inheritance` | [Missing inheritance](https://github.com/crytic/slither/wiki/Detector-Documentation#missing-inheritance) | Informational | High
-77 | `naming-convention` | [Conformity to Solidity naming conventions](https://github.com/crytic/slither/wiki/Detector-Documentation#conformance-to-solidity-naming-conventions) | Informational | High
-78 | `pragma` | [If different pragma directives are used](https://github.com/crytic/slither/wiki/Detector-Documentation#different-pragma-directives-are-used) | Informational | High
-79 | `redundant-statements` | [Redundant statements](https://github.com/crytic/slither/wiki/Detector-Documentation#redundant-statements) | Informational | High
-80 | `solc-version` | [Incorrect Solidity version](https://github.com/crytic/slither/wiki/Detector-Documentation#incorrect-versions-of-solidity) | Informational | High
-81 | `unimplemented-functions` | [Unimplemented functions](https://github.com/crytic/slither/wiki/Detector-Documentation#unimplemented-functions) | Informational | High
-82 | `unused-state` | [Unused state variables](https://github.com/crytic/slither/wiki/Detector-Documentation#unused-state-variable) | Informational | High
-83 | `costly-loop` | [Costly operations in a loop](https://github.com/crytic/slither/wiki/Detector-Documentation#costly-operations-inside-a-loop) | Informational | Medium
-84 | `dead-code` | [Functions that are not used](https://github.com/crytic/slither/wiki/Detector-Documentation#dead-code) | Informational | Medium
-85 | `reentrancy-unlimited-gas` | [Reentrancy vulnerabilities through send and transfer](https://github.com/crytic/slither/wiki/Detector-Documentation#reentrancy-vulnerabilities-4) | Informational | Medium
-86 | `similar-names` | [Variable names are too similar](https://github.com/crytic/slither/wiki/Detector-Documentation#variable-names-too-similar) | Informational | Medium
-87 | `too-many-digits` | [Conformance to numeric notation best practices](https://github.com/crytic/slither/wiki/Detector-Documentation#too-many-digits) | Informational | Medium
-88 | `cache-array-length` | [Detects `for` loops that use `length` member of some storage array in their loop condition and don't modify it.](https://github.com/crytic/slither/wiki/Detector-Documentation#cache-array-length) | Optimization | High
-89 | `constable-states` | [State variables that could be declared constant](https://github.com/crytic/slither/wiki/Detector-Documentation#state-variables-that-could-be-declared-constant) | Optimization | High
-90 | `external-function` | [Public function that could be declared external](https://github.com/crytic/slither/wiki/Detector-Documentation#public-function-that-could-be-declared-external) | Optimization | High
-91 | `immutable-states` | [State variables that could be declared immutable](https://github.com/crytic/slither/wiki/Detector-Documentation#state-variables-that-could-be-declared-immutable) | Optimization | High
-92 | `var-read-using-this` | [Contract reads its own variable using `this`](https://github.com/crytic/slither/wiki/Detector-Documentation#public-variable-read-in-external-context) | Optimization | High
+45 | `out-of-order-retryable` | [Out-of-order retryable transactions](https://github.com/crytic/slither/wiki/Detector-Documentation#out-of-order-retryable-transactions) | Medium | Medium
+46 | `reentrancy-no-eth` | [Reentrancy vulnerabilities (no theft of ethers)](https://github.com/crytic/slither/wiki/Detector-Documentation#reentrancy-vulnerabilities-1) | Medium | Medium
+47 | `reused-constructor` | [Reused base constructor](https://github.com/crytic/slither/wiki/Detector-Documentation#reused-base-constructors) | Medium | Medium
+48 | `tx-origin` | [Dangerous usage of `tx.origin`](https://github.com/crytic/slither/wiki/Detector-Documentation#dangerous-usage-of-txorigin) | Medium | Medium
+49 | `unchecked-lowlevel` | [Unchecked low-level calls](https://github.com/crytic/slither/wiki/Detector-Documentation#unchecked-low-level-calls) | Medium | Medium
+50 | `unchecked-send` | [Unchecked send](https://github.com/crytic/slither/wiki/Detector-Documentation#unchecked-send) | Medium | Medium
+51 | `uninitialized-local` | [Uninitialized local variables](https://github.com/crytic/slither/wiki/Detector-Documentation#uninitialized-local-variables) | Medium | Medium
+52 | `unused-return` | [Unused return values](https://github.com/crytic/slither/wiki/Detector-Documentation#unused-return) | Medium | Medium
+53 | `incorrect-modifier` | [Modifiers that can return the default value](https://github.com/crytic/slither/wiki/Detector-Documentation#incorrect-modifier) | Low | High
+54 | `shadowing-builtin` | [Built-in symbol shadowing](https://github.com/crytic/slither/wiki/Detector-Documentation#builtin-symbol-shadowing) | Low | High
+55 | `shadowing-local` | [Local variables shadowing](https://github.com/crytic/slither/wiki/Detector-Documentation#local-variable-shadowing) | Low | High
+56 | `uninitialized-fptr-cst` | [Uninitialized function pointer calls in constructors](https://github.com/crytic/slither/wiki/Detector-Documentation#uninitialized-function-pointers-in-constructors) | Low | High
+57 | `variable-scope` | [Local variables used prior their declaration](https://github.com/crytic/slither/wiki/Detector-Documentation#pre-declaration-usage-of-local-variables) | Low | High
+58 | `void-cst` | [Constructor called not implemented](https://github.com/crytic/slither/wiki/Detector-Documentation#void-constructor) | Low | High
+59 | `calls-loop` | [Multiple calls in a loop](https://github.com/crytic/slither/wiki/Detector-Documentation/#calls-inside-a-loop) | Low | Medium
+60 | `events-access` | [Missing Events Access Control](https://github.com/crytic/slither/wiki/Detector-Documentation#missing-events-access-control) | Low | Medium
+61 | `events-maths` | [Missing Events Arithmetic](https://github.com/crytic/slither/wiki/Detector-Documentation#missing-events-arithmetic) | Low | Medium
+62 | `incorrect-unary` | [Dangerous unary expressions](https://github.com/crytic/slither/wiki/Detector-Documentation#dangerous-unary-expressions) | Low | Medium
+63 | `missing-zero-check` | [Missing Zero Address Validation](https://github.com/crytic/slither/wiki/Detector-Documentation#missing-zero-address-validation) | Low | Medium
+64 | `reentrancy-benign` | [Benign reentrancy vulnerabilities](https://github.com/crytic/slither/wiki/Detector-Documentation#reentrancy-vulnerabilities-2) | Low | Medium
+65 | `reentrancy-events` | [Reentrancy vulnerabilities leading to out-of-order Events](https://github.com/crytic/slither/wiki/Detector-Documentation#reentrancy-vulnerabilities-3) | Low | Medium
+66 | `return-bomb` | [A low level callee may consume all callers gas unexpectedly.](https://github.com/crytic/slither/wiki/Detector-Documentation#return-bomb) | Low | Medium
+67 | `timestamp` | [Dangerous usage of `block.timestamp`](https://github.com/crytic/slither/wiki/Detector-Documentation#block-timestamp) | Low | Medium
+68 | `assembly` | [Assembly usage](https://github.com/crytic/slither/wiki/Detector-Documentation#assembly-usage) | Informational | High
+69 | `assert-state-change` | [Assert state change](https://github.com/crytic/slither/wiki/Detector-Documentation#assert-state-change) | Informational | High
+70 | `boolean-equal` | [Comparison to boolean constant](https://github.com/crytic/slither/wiki/Detector-Documentation#boolean-equality) | Informational | High
+71 | `cyclomatic-complexity` | [Detects functions with high (> 11) cyclomatic complexity](https://github.com/crytic/slither/wiki/Detector-Documentation#cyclomatic-complexity) | Informational | High
+72 | `deprecated-standards` | [Deprecated Solidity Standards](https://github.com/crytic/slither/wiki/Detector-Documentation#deprecated-standards) | Informational | High
+73 | `erc20-indexed` | [Un-indexed ERC20 event parameters](https://github.com/crytic/slither/wiki/Detector-Documentation#unindexed-erc20-event-parameters) | Informational | High
+74 | `function-init-state` | [Function initializing state variables](https://github.com/crytic/slither/wiki/Detector-Documentation#function-initializing-state) | Informational | High
+75 | `incorrect-using-for` | [Detects using-for statement usage when no function from a given library matches a given type](https://github.com/crytic/slither/wiki/Detector-Documentation#incorrect-using-for-usage) | Informational | High
+76 | `low-level-calls` | [Low level calls](https://github.com/crytic/slither/wiki/Detector-Documentation#low-level-calls) | Informational | High
+77 | `missing-inheritance` | [Missing inheritance](https://github.com/crytic/slither/wiki/Detector-Documentation#missing-inheritance) | Informational | High
+78 | `naming-convention` | [Conformity to Solidity naming conventions](https://github.com/crytic/slither/wiki/Detector-Documentation#conformance-to-solidity-naming-conventions) | Informational | High
+79 | `pragma` | [If different pragma directives are used](https://github.com/crytic/slither/wiki/Detector-Documentation#different-pragma-directives-are-used) | Informational | High
+80 | `redundant-statements` | [Redundant statements](https://github.com/crytic/slither/wiki/Detector-Documentation#redundant-statements) | Informational | High
+81 | `solc-version` | [Incorrect Solidity version](https://github.com/crytic/slither/wiki/Detector-Documentation#incorrect-versions-of-solidity) | Informational | High
+82 | `unimplemented-functions` | [Unimplemented functions](https://github.com/crytic/slither/wiki/Detector-Documentation#unimplemented-functions) | Informational | High
+83 | `unused-import` | [Detects unused imports](https://github.com/crytic/slither/wiki/Detector-Documentation#unused-imports) | Informational | High
+84 | `unused-state` | [Unused state variables](https://github.com/crytic/slither/wiki/Detector-Documentation#unused-state-variable) | Informational | High
+85 | `costly-loop` | [Costly operations in a loop](https://github.com/crytic/slither/wiki/Detector-Documentation#costly-operations-inside-a-loop) | Informational | Medium
+86 | `dead-code` | [Functions that are not used](https://github.com/crytic/slither/wiki/Detector-Documentation#dead-code) | Informational | Medium
+87 | `reentrancy-unlimited-gas` | [Reentrancy vulnerabilities through send and transfer](https://github.com/crytic/slither/wiki/Detector-Documentation#reentrancy-vulnerabilities-4) | Informational | Medium
+88 | `similar-names` | [Variable names are too similar](https://github.com/crytic/slither/wiki/Detector-Documentation#variable-names-too-similar) | Informational | Medium
+89 | `too-many-digits` | [Conformance to numeric notation best practices](https://github.com/crytic/slither/wiki/Detector-Documentation#too-many-digits) | Informational | Medium
+90 | `cache-array-length` | [Detects `for` loops that use `length` member of some storage array in their loop condition and don't modify it.](https://github.com/crytic/slither/wiki/Detector-Documentation#cache-array-length) | Optimization | High
+91 | `constable-states` | [State variables that could be declared constant](https://github.com/crytic/slither/wiki/Detector-Documentation#state-variables-that-could-be-declared-constant) | Optimization | High
+92 | `external-function` | [Public function that could be declared external](https://github.com/crytic/slither/wiki/Detector-Documentation#public-function-that-could-be-declared-external) | Optimization | High
+93 | `immutable-states` | [State variables that could be declared immutable](https://github.com/crytic/slither/wiki/Detector-Documentation#state-variables-that-could-be-declared-immutable) | Optimization | High
+94 | `var-read-using-this` | [Contract reads its own variable using `this`](https://github.com/crytic/slither/wiki/Detector-Documentation#public-variable-read-in-external-context) | Optimization | High
 
 For more information, see
 
@@ -297,7 +299,7 @@ Title | Usage | Authors | Venue | Code
 [Trace-Based Dynamic Gas Estimation of Loops in Smart Contracts](https://ieeexplore.ieee.org/stamp/stamp.jsp?arnumber=9268144) | Use Slither’s CFG to detect loops | Chunmiao Li, Shijie Nie, Yang Cao, Yijun Yu, Zhenjiang Hu | IEEE Open J. Comput. Soc. 1 (2020) | -
 [SAILFISH: Vetting Smart Contract State-Inconsistency Bugs in Seconds](https://arxiv.org/pdf/2104.08638.pdf) | Rely on SlithIR to build a *storage dependency graph* | Priyanka Bose, Dipanjan Das, Yanju Chen, Yu Feng, Christopher Kruegel, and Giovanni Vigna | S&P 22 | [Sailfish](https://github.com/ucsb-seclab/sailfish)
 [SolType: Refinement Types for Arithmetic Overflow in Solidity](https://arxiv.org/abs/2110.00677) | Use Slither as frontend to build refinement type system | Bryan Tan, Benjamin Mariano, Shuvendu K. Lahiri, Isil Dillig, Yu Feng | POPL 22 | -
-[Do Not Rug on Me: Leveraging Machine Learning Techniques for Automated Scam Detection](https://www.mdpi.com/2227-7390/10/6/949) | Use Slither to extract tokens' features (mintable, pausable, ..) | Mazorra, Bruno, Victor Adan, and Vanesa Daza | Mathematics 10.6 (2022)| -
+[Do Not Rug on Me: Leveraging Machine Learning Techniques for Automated Scam Detection](https://www.mdpi.com/2227-7390/10/6/949) | Use Slither to extract tokens' features (mintable, pausable, ..) | Mazorra, Bruno, Victor Adan, and Vanesa Daza | Mathematics 10.6 (2022) | -
 [MANDO: Multi-Level Heterogeneous Graph Embeddings for Fine-Grained Detection of Smart Contract Vulnerabilities](https://arxiv.org/abs/2208.13252) | Use Slither to extract the CFG and call graph | Hoang Nguyen, Nhat-Minh Nguyen, Chunyao Xie, Zahra Ahmadi, Daniel Kudendo, Thanh-Nam Doan and Lingxiao Jiang| IEEE 9th International Conference on Data Science and Advanced Analytics (DSAA, 2022) | [ge-sc](https://github.com/MANDO-Project/ge-sc)
 [Automated Auditing of Price Gouging TOD Vulnerabilities in Smart Contracts](https://www.cs.toronto.edu/~fanl/papers/price-icbc22.pdf) | Use Slither to extract the CFG and data dependencies| Sidi Mohamed Beillahi, Eric Keilty, Keerthi Nelaturu, Andreas Veneris, and Fan Long | 2022 IEEE International Conference on Blockchain and Cryptocurrency (ICBC) | [Smart-Contract-Repair](https://github.com/Veneris-Group/TOD-Location-Rectification)
 [Modeling and Enforcing Access Control Policies for Smart Contracts](https://publikationen.bibliothek.kit.edu/1000152805/151859658) | Extend Slither's data dependencies | Jan-Philipp Toberg, Jonas Schiffl, Frederik Reiche, Bernhard Beckert, Robert Heinrich, Ralf Reussner | IEEE International Conference on Decentralized Applications and Infrastructures (DAPPS), 2022  | [SolidityAccessControlEnforcement](https://github.com/KASTEL-CSSDA/SolidityAccessControlEnforcement)

examples/printers/human_printer.sol

@@ -65,7 +65,7 @@ contract SimpleVulnerableToken{
 
   /**
   * @dev Gets the balance of the specified address.
-  * @param _owner The address to query the the balance of.
+  * @param _owner The address to query the balance of.
   * @return An uint256 representing the amount owned by the passed address.
   */
   function balanceOf(address _owner) public view returns (uint256) {

examples/scripts/data_dependency.py

@@ -126,3 +126,17 @@ print(f"{var_tainted} is tainted: {is_tainted(var_tainted, contract)}")
 assert is_tainted(var_tainted, contract)
 print(f"{var_not_tainted} is tainted: {is_tainted(var_not_tainted, contract)}")
 assert not is_tainted(var_not_tainted, contract)
+
+print("SimpleModifier contract")
+contracts = slither.get_contract_from_name("SimpleModifier")
+assert len(contracts) == 1
+contract = contracts[0]
+dependent_state_var = contract.get_state_variable_from_name("owner")
+assert dependent_state_var
+baz = contract.get_modifier_from_signature("baz()")
+intermediate = baz.get_local_variable_from_name("intermediate")
+assert intermediate
+print(
+    f"{intermediate} depends on msg.sender: {is_dependent(intermediate, SolidityVariableComposed('msg.sender'), baz)}"
+)
+assert is_dependent(intermediate, SolidityVariableComposed("msg.sender"), baz)

examples/scripts/data_dependency.sol

@@ -115,3 +115,12 @@ contract PropagateThroughReturnValue {
     return (var_state);
   }
 }
+
+contract SimpleModifier {
+    address owner;
+    modifier baz {
+        bool intermediate = msg.sender == owner;
+        require(intermediate);
+        _;
+    }
+}

examples/scripts/possible_paths.py

@@ -19,7 +19,8 @@ def resolve_function(contract_name, function_name):
     contract = contracts[0]
     # Obtain the target function
     target_function = next(
-        (function for function in contract.functions if function.name == function_name), None
+        (function for function in contract.functions_declared if function.name == function_name),
+        None,
     )
 
     # Verify we have resolved the function specified.

plugin_example/setup.py

@@ -1,14 +1,14 @@
 from setuptools import setup, find_packages
 
 setup(
-    name="slither-my-plugins",
+    name="slither_my_plugin",
     description="This is an example of detectors and printers to Slither.",
     url="https://github.com/trailofbits/slither-plugins",
     author="Trail of Bits",
     version="0.0",
     packages=find_packages(),
     python_requires=">=3.8",
-    install_requires=["slither-analyzer==0.1"],
+    install_requires=["slither-analyzer>=0.6.0"],
     entry_points={
         "slither_analyzer.plugin": "slither my-plugin=slither_my_plugin:make_plugin",
     },

plugin_example/slither_my_plugin/detectors/example.py

@@ -11,12 +11,12 @@ class Example(AbstractDetector):  # pylint: disable=too-few-public-methods
     IMPACT = DetectorClassification.HIGH
     CONFIDENCE = DetectorClassification.HIGH
 
-    WIKI = ""
+    WIKI = "https://www.example.com/#example-detector"
 
-    WIKI_TITLE = ""
-    WIKI_DESCRIPTION = ""
-    WIKI_EXPLOIT_SCENARIO = ""
-    WIKI_RECOMMENDATION = ""
+    WIKI_TITLE = "example detector"
+    WIKI_DESCRIPTION = "This is an example detector that always generates a finding"
+    WIKI_EXPLOIT_SCENARIO = "Scenario goes here"
+    WIKI_RECOMMENDATION = "Customize the detector"
 
     def _detect(self):
 

pyproject.toml

@@ -7,7 +7,6 @@ missing-module-docstring,
 missing-class-docstring,
 missing-function-docstring,
 unnecessary-lambda,
-bad-continuation,
 cyclic-import,
 line-too-long,
 invalid-name,
@@ -18,5 +17,6 @@ logging-fstring-interpolation,
 logging-not-lazy,
 duplicate-code,
 import-error,
-unsubscriptable-object
+unsubscriptable-object,
+unnecessary-lambda-assignment
 """

scripts/ci_test.sh

@@ -1,84 +0,0 @@
-#!/usr/bin/env bash
-
-### Test Detectors
-
-DIR="$(cd "$(dirname "$0")" && pwd)"
-
-CURRENT_PATH=$(pwd)
-TRAVIS_PATH='/home/travis/build/crytic/slither'
-
-# test_slither file.sol detectors
-test_slither(){
-
-    expected="$DIR/../tests/expected_json/$(basename "$1" .sol).$2.json"
-
-    # run slither detector on input file and save output as json
-    if ! slither "$1" --solc-disable-warnings --detect "$2" --json "$DIR/tmp-test.json";
-    then
-        echo "Slither crashed"
-        exit 255
-    fi
-
-    if [ ! -f "$DIR/tmp-test.json" ]; then
-        echo ""
-        echo "Missing generated file"
-        echo ""
-        exit 1
-    fi
-    sed "s|$CURRENT_PATH|$TRAVIS_PATH|g" "$DIR/tmp-test.json" -i
-    result=$(python "$DIR/json_diff.py" "$expected" "$DIR/tmp-test.json")
-
-    rm "$DIR/tmp-test.json"
-    if [ "$result" != "{}" ]; then
-      echo ""
-      echo "failed test of file: $1, detector: $2"
-      echo ""
-      echo "$result"
-      echo ""
-      exit 1
-    fi
-
-    # run slither detector on input file and save output as json
-    if ! slither "$1" --solc-disable-warnings --detect "$2" --legacy-ast --json "$DIR/tmp-test.json";
-    then
-        echo "Slither crashed"
-        exit 255
-    fi
-
-    if [ ! -f "$DIR/tmp-test.json" ]; then
-        echo ""
-        echo "Missing generated file"
-        echo ""
-        exit 1
-    fi
-
-    sed "s|$CURRENT_PATH|$TRAVIS_PATH|g" "$DIR/tmp-test.json" -i
-    result=$(python "$DIR/json_diff.py" "$expected" "$DIR/tmp-test.json")
-
-    rm "$DIR/tmp-test.json"
-    if [ "$result" != "{}" ]; then
-      echo ""
-      echo "failed test of file: $1, detector: $2"
-      echo ""
-      echo "$result"
-      echo ""
-      exit 1
-    fi
-}
-
-# generate_expected_json file.sol detectors
-generate_expected_json(){
-    # generate output filename
-    # e.g. file: uninitialized.sol detector: uninitialized-state
-    # ---> uninitialized.uninitialized-state.json
-    output_filename="$DIR/../tests/expected_json/$(basename "$1" .sol).$2.json"
-    output_filename_txt="$DIR/../tests/expected_json/$(basename "$1" .sol).$2.txt"
-
-    # run slither detector on input file and save output as json
-    slither "$1" --solc-disable-warnings --detect "$2" --json "$output_filename" > "$output_filename_txt" 2>&1
-
-
-    sed "s|$CURRENT_PATH|$TRAVIS_PATH|g" "$output_filename" -i
-    sed "s|$CURRENT_PATH|$TRAVIS_PATH|g" "$output_filename_txt" -i
-}
-

scripts/json_diff.py

@@ -1,27 +0,0 @@
-import sys
-import json
-from pprint import pprint
-from deepdiff import DeepDiff  # pip install deepdiff
-
-
-if len(sys.argv) != 3:
-    print("Usage: python json_diff.py 1.json 2.json")
-    sys.exit(-1)
-
-with open(sys.argv[1], encoding="utf8") as f:
-    d1 = json.load(f)
-
-with open(sys.argv[2], encoding="utf8") as f:
-    d2 = json.load(f)
-
-
-# Remove description field to allow non deterministic print
-for elem in d1:
-    if "description" in elem:
-        del elem["description"]
-for elem in d2:
-    if "description" in elem:
-        del elem["description"]
-
-
-pprint(DeepDiff(d1, d2, ignore_order=True, verbose_level=2))

scripts/update_buggy_versions.py

@@ -0,0 +1,28 @@
+import json
+from pathlib import Path
+import urllib.request
+
+
+def retrieve_json(url):
+    with urllib.request.urlopen(url) as response:
+        data = response.read().decode("utf-8")
+        return json.loads(data)
+
+
+def organize_data(json_data):
+    version_bugs = {}
+    for version, info in json_data.items():
+        version_bugs[version] = info["bugs"]
+    return version_bugs
+
+
+if __name__ == "__main__":
+    bug_list_url = (
+        "https://raw.githubusercontent.com/ethereum/solidity/develop/docs/bugs_by_version.json"
+    )
+    bug_data = retrieve_json(bug_list_url)
+    bugs_by_version = organize_data(bug_data)
+
+    with open(Path.cwd() / Path("slither/utils/buggy_versions.py"), "w", encoding="utf-8") as file:
+        file.write("# pylint: disable=too-many-lines\n")
+        file.write(f"bugs_by_version = {bugs_by_version}")

setup.py

@@ -8,14 +8,14 @@ setup(
     description="Slither is a Solidity and Vyper static analysis framework written in Python 3.",
     url="https://github.com/crytic/slither",
     author="Trail of Bits",
-    version="0.10.0",
+    version="0.10.2",
     packages=find_packages(),
     python_requires=">=3.8",
     install_requires=[
         "packaging",
         "prettytable>=3.3.0",
         "pycryptodome>=3.4.6",
-        "crytic-compile>=0.3.5,<0.4.0",
+        "crytic-compile>=0.3.7,<0.4.0",
         # "crytic-compile@git+https://github.com/crytic/crytic-compile.git@master#egg=crytic-compile",
         "web3>=6.0.0",
         "eth-abi>=4.0.0",
@@ -25,7 +25,7 @@ setup(
     extras_require={
         "lint": [
             "black==22.3.0",
-            "pylint==2.13.4",
+            "pylint==3.0.3",
         ],
         "test": [
             "pytest",

slither/__main__.py

@@ -10,11 +10,11 @@ import os
 import pstats
 import sys
 import traceback
-from typing import Tuple, Optional, List, Dict, Type, Union, Any, Sequence
+from importlib import metadata
+from typing import Any, Dict, List, Optional, Sequence, Set, Tuple, Type, Union
 
-from pkg_resources import iter_entry_points, require
 
-from crytic_compile import cryticparser, CryticCompile
+from crytic_compile import cryticparser, CryticCompile, InvalidCompilation
 from crytic_compile.platform.standard import generate_standard_export
 from crytic_compile.platform.etherscan import SUPPORTED_NETWORK
 from crytic_compile import compile_all, is_supported
@@ -93,7 +93,13 @@ def process_all(
     detector_classes: List[Type[AbstractDetector]],
     printer_classes: List[Type[AbstractPrinter]],
 ) -> Tuple[List[Slither], List[Dict], List[Output], int]:
-    compilations = compile_all(target, **vars(args))
+
+    try:
+        compilations = compile_all(target, **vars(args))
+    except InvalidCompilation:
+        logger.error("Unable to compile all targets.")
+        sys.exit(2)
+
     slither_instances = []
     results_detectors = []
     results_printers = []
@@ -166,19 +172,26 @@ def get_detectors_and_printers() -> Tuple[
     printers = [p for p in printers_ if inspect.isclass(p) and issubclass(p, AbstractPrinter)]
 
     # Handle plugins!
-    for entry_point in iter_entry_points(group="slither_analyzer.plugin", name=None):
+    if sys.version_info >= (3, 10):
+        entry_points = metadata.entry_points(group="slither_analyzer.plugin")
+    else:
+        from pkg_resources import iter_entry_points  # pylint: disable=import-outside-toplevel
+
+        entry_points = iter_entry_points(group="slither_analyzer.plugin", name=None)
+
+    for entry_point in entry_points:
         make_plugin = entry_point.load()
 
         plugin_detectors, plugin_printers = make_plugin()
 
         detector = None
         if not all(issubclass(detector, AbstractDetector) for detector in plugin_detectors):
-            raise Exception(
+            raise ValueError(
                 f"Error when loading plugin {entry_point}, {detector} is not a detector"
             )
         printer = None
         if not all(issubclass(printer, AbstractPrinter) for printer in plugin_printers):
-            raise Exception(f"Error when loading plugin {entry_point}, {printer} is not a printer")
+            raise ValueError(f"Error when loading plugin {entry_point}, {printer} is not a printer")
 
         # We convert those to lists in case someone returns a tuple
         detectors += list(plugin_detectors)
@@ -198,44 +211,51 @@ def choose_detectors(
 
     if args.detectors_to_run == "all":
         detectors_to_run = all_detector_classes
-        if args.detectors_to_exclude:
-            detectors_excluded = args.detectors_to_exclude.split(",")
-            for detector in detectors:
-                if detector in detectors_excluded:
-                    detectors_to_run.remove(detectors[detector])
     else:
-        for detector in args.detectors_to_run.split(","):
-            if detector in detectors:
-                detectors_to_run.append(detectors[detector])
-            else:
-                raise Exception(f"Error: {detector} is not a detector")
-        detectors_to_run = sorted(detectors_to_run, key=lambda x: x.IMPACT)
+        detectors_to_run = __include_detectors(
+            set(detectors_to_run), args.detectors_to_run, detectors
+        )
         return detectors_to_run
 
-    if args.exclude_optimization:
-        detectors_to_run = [
-            d for d in detectors_to_run if d.IMPACT != DetectorClassification.OPTIMIZATION
-        ]
+    classification_map = {
+        DetectorClassification.HIGH: args.exclude_high,
+        DetectorClassification.MEDIUM: args.exclude_medium,
+        DetectorClassification.LOW: args.exclude_low,
+        DetectorClassification.INFORMATIONAL: args.exclude_informational,
+        DetectorClassification.OPTIMIZATION: args.exclude_optimization,
+    }
+    excluded_classification = [
+        classification for classification, included in classification_map.items() if included
+    ]
+    detectors_to_run = [d for d in detectors_to_run if d.IMPACT not in excluded_classification]
 
-    if args.exclude_informational:
-        detectors_to_run = [
-            d for d in detectors_to_run if d.IMPACT != DetectorClassification.INFORMATIONAL
-        ]
-    if args.exclude_low:
-        detectors_to_run = [d for d in detectors_to_run if d.IMPACT != DetectorClassification.LOW]
-    if args.exclude_medium:
-        detectors_to_run = [
-            d for d in detectors_to_run if d.IMPACT != DetectorClassification.MEDIUM
-        ]
-    if args.exclude_high:
-        detectors_to_run = [d for d in detectors_to_run if d.IMPACT != DetectorClassification.HIGH]
     if args.detectors_to_exclude:
         detectors_to_run = [
             d for d in detectors_to_run if d.ARGUMENT not in args.detectors_to_exclude
         ]
 
-    detectors_to_run = sorted(detectors_to_run, key=lambda x: x.IMPACT)
+    if args.detectors_to_include:
+        detectors_to_run = __include_detectors(
+            set(detectors_to_run), args.detectors_to_include, detectors
+        )
+
+    return detectors_to_run
+
+
+def __include_detectors(
+    detectors_to_run: Set[Type[AbstractDetector]],
+    detectors_to_include: str,
+    detectors: Dict[str, Type[AbstractDetector]],
+) -> List[Type[AbstractDetector]]:
+    include_detectors = detectors_to_include.split(",")
+
+    for detector in include_detectors:
+        if detector in detectors:
+            detectors_to_run.add(detectors[detector])
+        else:
+            raise ValueError(f"Error: {detector} is not a detector")
 
+    detectors_to_run = sorted(detectors_to_run, key=lambda x: x.IMPACT)
     return detectors_to_run
 
 
@@ -256,7 +276,7 @@ def choose_printers(
         if printer in printers:
             printers_to_run.append(printers[printer])
         else:
-            raise Exception(f"Error: {printer} is not a printer")
+            raise ValueError(f"Error: {printer} is not a printer")
     return printers_to_run
 
 
@@ -268,9 +288,10 @@ def choose_printers(
 ###################################################################################
 
 
-def parse_filter_paths(args: argparse.Namespace) -> List[str]:
-    if args.filter_paths:
-        return args.filter_paths.split(",")
+def parse_filter_paths(args: argparse.Namespace, filter_path: bool) -> List[str]:
+    paths = args.filter_paths if filter_path else args.include_paths
+    if paths:
+        return paths.split(",")
     return []
 
 
@@ -297,7 +318,7 @@ def parse_args(
     parser.add_argument(
         "--version",
         help="displays the current version",
-        version=require("slither-analyzer")[0].version,
+        version=metadata.version("slither-analyzer"),
         action="version",
     )
 
@@ -307,6 +328,7 @@ def parse_args(
         "Checklist (consider using https://github.com/crytic/slither-action)"
     )
     group_misc = parser.add_argument_group("Additional options")
+    group_filters = parser.add_mutually_exclusive_group()
 
     group_detector.add_argument(
         "--detect",
@@ -392,6 +414,14 @@ def parse_args(
         default=defaults_flag_in_config["exclude_high"],
     )
 
+    group_detector.add_argument(
+        "--include-detectors",
+        help="Comma-separated list of detectors that should be included",
+        action="store",
+        dest="detectors_to_include",
+        default=defaults_flag_in_config["detectors_to_include"],
+    )
+
     fail_on_group = group_detector.add_mutually_exclusive_group()
     fail_on_group.add_argument(
         "--fail-pedantic",
@@ -518,22 +548,22 @@ def parse_args(
         default=defaults_flag_in_config["disable_color"],
     )
 
-    group_misc.add_argument(
-        "--filter-paths",
-        help="Regex filter to exclude detector results matching file path e.g. (mocks/|test/)",
-        action="store",
-        dest="filter_paths",
-        default=defaults_flag_in_config["filter_paths"],
-    )
-
     group_misc.add_argument(
         "--triage-mode",
-        help="Run triage mode (save results in slither.db.json)",
+        help="Run triage mode (save results in triage database)",
         action="store_true",
         dest="triage_mode",
         default=False,
     )
 
+    group_misc.add_argument(
+        "--triage-database",
+        help="File path to the triage database (default: slither.db.json)",
+        action="store",
+        dest="triage_database",
+        default=defaults_flag_in_config["triage_database"],
+    )
+
     group_misc.add_argument(
         "--config-file",
         help="Provide a config file (default: slither.config.json)",
@@ -571,6 +601,22 @@ def parse_args(
         default=defaults_flag_in_config["no_fail"],
     )
 
+    group_filters.add_argument(
+        "--filter-paths",
+        help="Regex filter to exclude detector results matching file path e.g. (mocks/|test/)",
+        action="store",
+        dest="filter_paths",
+        default=defaults_flag_in_config["filter_paths"],
+    )
+
+    group_filters.add_argument(
+        "--include-paths",
+        help="Regex filter to include detector results matching file path e.g. (src/|contracts/). Opposite of --filter-paths",
+        action="store",
+        dest="include_paths",
+        default=defaults_flag_in_config["include_paths"],
+    )
+
     codex.init_parser(parser)
 
     # debugger command
@@ -623,13 +669,14 @@ def parse_args(
     args = parser.parse_args()
     read_config_file(args)
 
-    args.filter_paths = parse_filter_paths(args)
+    args.filter_paths = parse_filter_paths(args, True)
+    args.include_paths = parse_filter_paths(args, False)
 
     # Verify our json-type output is valid
     args.json_types = set(args.json_types.split(","))  # type:ignore
     for json_type in args.json_types:
         if json_type not in JSON_OUTPUT_TYPES:
-            raise Exception(f'Error: "{json_type}" is not a valid JSON result output type.')
+            raise ValueError(f'Error: "{json_type}" is not a valid JSON result output type.')
 
     return args
 

slither/analyses/evm/convert.py

@@ -178,15 +178,14 @@ def generate_source_to_evm_ins_mapping(evm_instructions, srcmap_runtime, slither
         # In order to compress these source mappings especially for bytecode, the following rules are used:
         # If a field is empty, the value of the preceding element is used.
         # If a : is missing, all following fields are considered empty.
-
         mapping_item = mapping.split(":")
         mapping_item += prev_mapping[len(mapping_item) :]
 
         for i, _ in enumerate(mapping_item):
             if mapping_item[i] == "":
-                mapping_item[i] = int(prev_mapping[i])
+                mapping_item[i] = prev_mapping[i]
 
-        offset, _length, file_id, *_ = mapping_item
+        offset, _, file_id, *_ = mapping_item
         prev_mapping = mapping_item
 
         if file_id == "-1":
@@ -194,8 +193,7 @@ def generate_source_to_evm_ins_mapping(evm_instructions, srcmap_runtime, slither
             # See https://github.com/ethereum/solidity/issues/6119#issuecomment-467797635
             continue
 
-        offset = int(offset)
-        line_number = file_source[0:offset].count("\n".encode("utf-8")) + 1
+        line_number = file_source[0 : int(offset)].count("\n".encode("utf-8")) + 1
 
         # Append evm instructions to the corresponding source line number
         # Note: Some evm instructions in mapping are not necessarily in program execution order

slither/core/cfg/node.py

@@ -11,6 +11,7 @@ from slither.core.declarations.solidity_variables import (
     SolidityFunction,
 )
 from slither.core.expressions.expression import Expression
+from slither.core.expressions import CallExpression, Identifier, AssignmentOperation
 from slither.core.solidity_types import ElementaryType
 from slither.core.source_mapping.source_mapping import SourceMapping
 from slither.core.variables.local_variable import LocalVariable
@@ -898,6 +899,21 @@ class Node(SourceMapping):  # pylint: disable=too-many-public-methods
                 # TODO: consider removing dependancy of solidity_call to internal_call
                 self._solidity_calls.append(ir.function)
                 self._internal_calls.append(ir.function)
+            if (
+                isinstance(ir, SolidityCall)
+                and ir.function == SolidityFunction("sstore(uint256,uint256)")
+                and isinstance(ir.node.expression, CallExpression)
+                and isinstance(ir.node.expression.arguments[0], Identifier)
+            ):
+                self._vars_written.append(ir.arguments[0])
+            if (
+                isinstance(ir, SolidityCall)
+                and ir.function == SolidityFunction("sload(uint256)")
+                and isinstance(ir.node.expression, AssignmentOperation)
+                and isinstance(ir.node.expression.expression_right, CallExpression)
+                and isinstance(ir.node.expression.expression_right.arguments[0], Identifier)
+            ):
+                self._vars_read.append(ir.arguments[0])
             if isinstance(ir, LowLevelCall):
                 assert isinstance(ir.destination, (Variable, SolidityVariable))
                 self._low_level_calls.append((ir.destination, str(ir.function_name.value)))

slither/core/compilation_unit.py

@@ -16,6 +16,7 @@ from slither.core.declarations import (
 )
 from slither.core.declarations.custom_error_top_level import CustomErrorTopLevel
 from slither.core.declarations.enum_top_level import EnumTopLevel
+from slither.core.declarations.event_top_level import EventTopLevel
 from slither.core.declarations.function_top_level import FunctionTopLevel
 from slither.core.declarations.structure_top_level import StructureTopLevel
 from slither.core.declarations.using_for_top_level import UsingForTopLevel
@@ -57,6 +58,7 @@ class SlitherCompilationUnit(Context):
         self.contracts: List[Contract] = []
         self._structures_top_level: List[StructureTopLevel] = []
         self._enums_top_level: List[EnumTopLevel] = []
+        self._events_top_level: List[EventTopLevel] = []
         self._variables_top_level: List[TopLevelVariable] = []
         self._functions_top_level: List[FunctionTopLevel] = []
         self._using_for_top_level: List[UsingForTopLevel] = []
@@ -234,6 +236,10 @@ class SlitherCompilationUnit(Context):
     def enums_top_level(self) -> List[EnumTopLevel]:
         return self._enums_top_level
 
+    @property
+    def events_top_level(self) -> List[EventTopLevel]:
+        return self._events_top_level
+
     @property
     def variables_top_level(self) -> List[TopLevelVariable]:
         return self._variables_top_level
@@ -296,10 +302,7 @@ class SlitherCompilationUnit(Context):
 
             slot = 0
             offset = 0
-            for var in contract.state_variables_ordered:
-                if var.is_constant or var.is_immutable:
-                    continue
-
+            for var in contract.stored_state_variables_ordered:
                 assert var.type
                 size, new_slot = var.type.storage_size
 

slither/core/declarations/__init__.py

@@ -1,6 +1,8 @@
 from .contract import Contract
 from .enum import Enum
 from .event import Event
+from .event_contract import EventContract
+from .event_top_level import EventTopLevel
 from .function import Function
 from .import_directive import Import
 from .modifier import Modifier

slither/core/declarations/contract.py

@@ -9,9 +9,8 @@ from typing import Optional, List, Dict, Callable, Tuple, TYPE_CHECKING, Union,
 from crytic_compile.platform import Type as PlatformType
 
 from slither.core.cfg.scope import Scope
-from slither.core.solidity_types.type import Type
 from slither.core.source_mapping.source_mapping import SourceMapping
-
+from slither.utils.using_for import USING_FOR, merge_using_for
 from slither.core.declarations.function import Function, FunctionType, FunctionLanguage
 from slither.utils.erc import (
     ERC20_signatures,
@@ -33,7 +32,7 @@ if TYPE_CHECKING:
     from slither.utils.type_helpers import LibraryCallType, HighLevelCallType, InternalCallType
     from slither.core.declarations import (
         Enum,
-        Event,
+        EventContract,
         Modifier,
         EnumContract,
         StructureContract,
@@ -50,9 +49,6 @@ if TYPE_CHECKING:
 
 LOGGER = logging.getLogger("Contract")
 
-USING_FOR_KEY = Union[str, Type]
-USING_FOR_ITEM = List[Union[Type, Function]]
-
 
 class Contract(SourceMapping):  # pylint: disable=too-many-public-methods
     """
@@ -73,7 +69,7 @@ class Contract(SourceMapping):  # pylint: disable=too-many-public-methods
 
         self._enums: Dict[str, "EnumContract"] = {}
         self._structures: Dict[str, "StructureContract"] = {}
-        self._events: Dict[str, "Event"] = {}
+        self._events: Dict[str, "EventContract"] = {}
         # map accessible variable from name -> variable
         # do not contain private variables inherited from contract
         self._variables: Dict[str, "StateVariable"] = {}
@@ -87,12 +83,13 @@ class Contract(SourceMapping):  # pylint: disable=too-many-public-methods
         self._type_aliases: Dict[str, "TypeAliasContract"] = {}
 
         # The only str is "*"
-        self._using_for: Dict[USING_FOR_KEY, USING_FOR_ITEM] = {}
-        self._using_for_complete: Optional[Dict[USING_FOR_KEY, USING_FOR_ITEM]] = None
+        self._using_for: USING_FOR = {}
+        self._using_for_complete: Optional[USING_FOR] = None
         self._kind: Optional[str] = None
         self._is_interface: bool = False
         self._is_library: bool = False
         self._is_fully_implemented: bool = False
+        self._is_abstract: bool = False
 
         self._signatures: Optional[List[str]] = None
         self._signatures_declared: Optional[List[str]] = None
@@ -203,12 +200,34 @@ class Contract(SourceMapping):  # pylint: disable=too-many-public-methods
 
     @property
     def is_fully_implemented(self) -> bool:
+        """
+        bool: True if the contract defines all functions.
+        In modern Solidity, virtual functions can lack an implementation.
+        Prior to Solidity 0.6.0, functions like the following would be not fully implemented:
+        ```solidity
+        contract ImplicitAbstract{
+            function f() public;
+        }
+        ```
+        """
         return self._is_fully_implemented
 
     @is_fully_implemented.setter
     def is_fully_implemented(self, is_fully_implemented: bool):
         self._is_fully_implemented = is_fully_implemented
 
+    @property
+    def is_abstract(self) -> bool:
+        """
+        Note for Solidity < 0.6.0 it will always be false
+        bool: True if the contract is abstract.
+        """
+        return self._is_abstract
+
+    @is_abstract.setter
+    def is_abstract(self, is_abstract: bool):
+        self._is_abstract = is_abstract
+
     # endregion
     ###################################################################################
     ###################################################################################
@@ -278,28 +297,28 @@ class Contract(SourceMapping):  # pylint: disable=too-many-public-methods
     ###################################################################################
 
     @property
-    def events(self) -> List["Event"]:
+    def events(self) -> List["EventContract"]:
         """
         list(Event): List of the events
         """
         return list(self._events.values())
 
     @property
-    def events_inherited(self) -> List["Event"]:
+    def events_inherited(self) -> List["EventContract"]:
         """
         list(Event): List of the inherited events
         """
         return [e for e in self.events if e.contract != self]
 
     @property
-    def events_declared(self) -> List["Event"]:
+    def events_declared(self) -> List["EventContract"]:
         """
         list(Event): List of the events declared within the contract (not inherited)
         """
         return [e for e in self.events if e.contract == self]
 
     @property
-    def events_as_dict(self) -> Dict[str, "Event"]:
+    def events_as_dict(self) -> Dict[str, "EventContract"]:
         return self._events
 
     # endregion
@@ -310,29 +329,20 @@ class Contract(SourceMapping):  # pylint: disable=too-many-public-methods
     ###################################################################################
 
     @property
-    def using_for(self) -> Dict[USING_FOR_KEY, USING_FOR_ITEM]:
+    def using_for(self) -> USING_FOR:
         return self._using_for
 
     @property
-    def using_for_complete(self) -> Dict[USING_FOR_KEY, USING_FOR_ITEM]:
+    def using_for_complete(self) -> USING_FOR:
         """
-        Dict[Union[str, Type], List[Type]]: Dict of merged local using for directive with top level directive
+        USING_FOR: Dict of merged local using for directive with top level directive
         """
 
-        def _merge_using_for(
-            uf1: Dict[USING_FOR_KEY, USING_FOR_ITEM], uf2: Dict[USING_FOR_KEY, USING_FOR_ITEM]
-        ) -> Dict[USING_FOR_KEY, USING_FOR_ITEM]:
-            result = {**uf1, **uf2}
-            for key, value in result.items():
-                if key in uf1 and key in uf2:
-                    result[key] = value + uf1[key]
-            return result
-
         if self._using_for_complete is None:
             result = self.using_for
             top_level_using_for = self.file_scope.using_for_directives
             for uftl in top_level_using_for:
-                result = _merge_using_for(result, uftl.using_for)
+                result = merge_using_for(result, uftl.using_for)
             self._using_for_complete = result
         return self._using_for_complete
 
@@ -436,6 +446,33 @@ class Contract(SourceMapping):  # pylint: disable=too-many-public-methods
         """
         return list(self._variables.values())
 
+    @property
+    def stored_state_variables(self) -> List["StateVariable"]:
+        """
+        Returns state variables with storage locations, excluding private variables from inherited contracts.
+        Use stored_state_variables_ordered to access variables with storage locations in their declaration order.
+
+        This implementation filters out state variables if they are constant or immutable. It will be
+        updated to accommodate any new non-storage keywords that might replace 'constant' and 'immutable' in the future.
+
+        Returns:
+            List[StateVariable]: A list of state variables with storage locations.
+        """
+        return [variable for variable in self.state_variables if variable.is_stored]
+
+    @property
+    def stored_state_variables_ordered(self) -> List["StateVariable"]:
+        """
+        list(StateVariable): List of the state variables with storage locations by order of declaration.
+
+        This implementation filters out state variables if they are constant or immutable. It will be
+        updated to accommodate any new non-storage keywords that might replace 'constant' and 'immutable' in the future.
+
+        Returns:
+            List[StateVariable]: A list of state variables with storage locations ordered by declaration.
+        """
+        return [variable for variable in self.state_variables_ordered if variable.is_stored]
+
     @property
     def state_variables_entry_points(self) -> List["StateVariable"]:
         """
@@ -867,7 +904,7 @@ class Contract(SourceMapping):  # pylint: disable=too-many-public-methods
 
     def get_function_from_canonical_name(self, canonical_name: str) -> Optional["Function"]:
         """
-            Return a function from a a canonical name (contract.signature())
+            Return a function from a canonical name (contract.signature())
         Args:
             canonical_name (str): canonical name of the function (without return statement)
         Returns:
@@ -969,16 +1006,14 @@ class Contract(SourceMapping):  # pylint: disable=too-many-public-methods
 
     def get_functions_overridden_by(self, function: "Function") -> List["Function"]:
         """
-            Return the list of functions overriden by the function
+            Return the list of functions overridden by the function
         Args:
             (core.Function)
         Returns:
             list(core.Function)
 
         """
-        candidatess = [c.functions_declared for c in self.inheritance]
-        candidates = [candidate for sublist in candidatess for candidate in sublist]
-        return [f for f in candidates if f.full_name == function.full_name]
+        return function.overrides
 
     # endregion
     ###################################################################################

slither/core/declarations/custom_error.py

@@ -17,6 +17,7 @@ class CustomError(SourceMapping):
 
         self._solidity_signature: Optional[str] = None
         self._full_name: Optional[str] = None
+        self._pattern = "error"
 
     @property
     def name(self) -> str:

slither/core/declarations/event.py

@@ -1,14 +1,10 @@
-from typing import List, Tuple, TYPE_CHECKING
+from typing import List, Tuple
 
-from slither.core.declarations.contract_level import ContractLevel
 from slither.core.source_mapping.source_mapping import SourceMapping
 from slither.core.variables.event_variable import EventVariable
 
-if TYPE_CHECKING:
-    from slither.core.declarations import Contract
 
-
-class Event(ContractLevel, SourceMapping):
+class Event(SourceMapping):
     def __init__(self) -> None:
         super().__init__()
         self._name = None
@@ -39,25 +35,9 @@ class Event(ContractLevel, SourceMapping):
         name, parameters = self.signature
         return name + "(" + ",".join(parameters) + ")"
 
-    @property
-    def canonical_name(self) -> str:
-        """Return the function signature as a str
-        Returns:
-            str: contract.func_name(type1,type2)
-        """
-        return self.contract.name + "." + self.full_name
-
     @property
     def elems(self) -> List["EventVariable"]:
         return self._elems
 
-    def is_declared_by(self, contract: "Contract") -> bool:
-        """
-        Check if the element is declared by the contract
-        :param contract:
-        :return:
-        """
-        return self.contract == contract
-
     def __str__(self) -> str:
         return self.name

slither/core/declarations/event_contract.py

@@ -0,0 +1,25 @@
+from typing import TYPE_CHECKING
+
+from slither.core.declarations.contract_level import ContractLevel
+from slither.core.declarations import Event
+
+if TYPE_CHECKING:
+    from slither.core.declarations import Contract
+
+
+class EventContract(Event, ContractLevel):
+    def is_declared_by(self, contract: "Contract") -> bool:
+        """
+        Check if the element is declared by the contract
+        :param contract:
+        :return:
+        """
+        return self.contract == contract
+
+    @property
+    def canonical_name(self) -> str:
+        """Return the function signature as a str
+        Returns:
+            str: contract.func_name(type1,type2)
+        """
+        return self.contract.name + "." + self.full_name

slither/core/declarations/event_top_level.py

@@ -0,0 +1,13 @@
+from typing import TYPE_CHECKING
+
+from slither.core.declarations import Event
+from slither.core.declarations.top_level import TopLevel
+
+if TYPE_CHECKING:
+    from slither.core.scope.scope import FileScope
+
+
+class EventTopLevel(Event, TopLevel):
+    def __init__(self, scope: "FileScope") -> None:
+        super().__init__()
+        self.file_scope: "FileScope" = scope

slither/core/declarations/function.py

@@ -37,7 +37,7 @@ if TYPE_CHECKING:
         HighLevelCallType,
         LibraryCallType,
     )
-    from slither.core.declarations import Contract
+    from slither.core.declarations import Contract, FunctionContract
     from slither.core.cfg.node import Node, NodeType
     from slither.core.variables.variable import Variable
     from slither.slithir.variables.variable import SlithIRVariable
@@ -46,7 +46,6 @@ if TYPE_CHECKING:
     from slither.slithir.operations import Operation
     from slither.core.compilation_unit import SlitherCompilationUnit
     from slither.core.scope.scope import FileScope
-    from slither.slithir.variables.state_variable import StateIRVariable
 
 LOGGER = logging.getLogger("Function")
 ReacheableNode = namedtuple("ReacheableNode", ["node", "ir"])
@@ -95,14 +94,11 @@ class FunctionType(Enum):
 
 def _filter_state_variables_written(expressions: List["Expression"]):
     ret = []
+
     for expression in expressions:
-        if isinstance(expression, Identifier):
-            ret.append(expression)
-        if isinstance(expression, UnaryOperation):
-            ret.append(expression.expression)
-        if isinstance(expression, MemberAccess):
+        if isinstance(expression, (Identifier, UnaryOperation, MemberAccess)):
             ret.append(expression.expression)
-        if isinstance(expression, IndexAccess):
+        elif isinstance(expression, IndexAccess):
             ret.append(expression.expression_left)
     return ret
 
@@ -126,6 +122,9 @@ class Function(SourceMapping, metaclass=ABCMeta):  # pylint: disable=too-many-pu
         self._pure: bool = False
         self._payable: bool = False
         self._visibility: Optional[str] = None
+        self._virtual: bool = False
+        self._overrides: List["FunctionContract"] = []
+        self._overridden_by: List["FunctionContract"] = []
 
         self._is_implemented: Optional[bool] = None
         self._is_empty: Optional[bool] = None
@@ -175,6 +174,8 @@ class Function(SourceMapping, metaclass=ABCMeta):  # pylint: disable=too-many-pu
         self._all_library_calls: Optional[List["LibraryCallType"]] = None
         self._all_low_level_calls: Optional[List["LowLevelCallType"]] = None
         self._all_solidity_calls: Optional[List["SolidityFunction"]] = None
+        self._all_variables_read: Optional[List["Variable"]] = None
+        self._all_variables_written: Optional[List["Variable"]] = None
         self._all_state_variables_read: Optional[List["StateVariable"]] = None
         self._all_solidity_variables_read: Optional[List["SolidityVariable"]] = None
         self._all_state_variables_written: Optional[List["StateVariable"]] = None
@@ -351,8 +352,7 @@ class Function(SourceMapping, metaclass=ABCMeta):  # pylint: disable=too-many-pu
     @property
     def id(self) -> Optional[str]:
         """
-        Return the ID of the funciton. For Solidity with compact-AST the ID is the reference ID
-        For other, the ID is None
+        Return the reference ID of the function, if available.
 
         :return:
         :rtype:
@@ -441,6 +441,49 @@ class Function(SourceMapping, metaclass=ABCMeta):  # pylint: disable=too-many-pu
     def payable(self, p: bool):
         self._payable = p
 
+    # endregion
+    ###################################################################################
+    ###################################################################################
+    # region Virtual
+    ###################################################################################
+    ###################################################################################
+
+    @property
+    def is_virtual(self) -> bool:
+        """
+        Note for Solidity < 0.6.0 it will always be false
+        bool: True if the function is virtual
+        """
+        return self._virtual
+
+    @is_virtual.setter
+    def is_virtual(self, v: bool):
+        self._virtual = v
+
+    @property
+    def is_override(self) -> bool:
+        """
+        Note for Solidity < 0.6.0 it will always be false
+        bool: True if the function overrides a base function
+        """
+        return len(self._overrides) > 0
+
+    @property
+    def overridden_by(self) -> List["FunctionContract"]:
+        """
+        List["FunctionContract"]: List of functions in child contracts that override this function
+        This may include distinct instances of the same function due to inheritance
+        """
+        return self._overridden_by
+
+    @property
+    def overrides(self) -> List["FunctionContract"]:
+        """
+        List["FunctionContract"]: List of functions in parent contracts that this function overrides
+        This may include distinct instances of the same function due to inheritance
+        """
+        return self._overrides
+
     # endregion
     ###################################################################################
     ###################################################################################
@@ -1108,6 +1151,18 @@ class Function(SourceMapping, metaclass=ABCMeta):  # pylint: disable=too-many-pu
 
         return list(set(values))
 
+    def all_variables_read(self) -> List["Variable"]:
+        """recursive version of variables_read"""
+        if self._all_variables_read is None:
+            self._all_variables_read = self._explore_functions(lambda x: x.variables_read)
+        return self._all_variables_read
+
+    def all_variables_written(self) -> List["Variable"]:
+        """recursive version of variables_written"""
+        if self._all_variables_written is None:
+            self._all_variables_written = self._explore_functions(lambda x: x.variables_written)
+        return self._all_variables_written
+
     def all_state_variables_read(self) -> List["StateVariable"]:
         """recursive version of variables_read"""
         if self._all_state_variables_read is None:
@@ -1500,10 +1555,13 @@ class Function(SourceMapping, metaclass=ABCMeta):  # pylint: disable=too-many-pu
         """
         Determine if the function can be re-entered
         """
+        reentrancy_modifier = "nonReentrant"
+
+        if self.function_language == FunctionLanguage.Vyper:
+            reentrancy_modifier = "nonreentrant(lock)"
+
         # TODO: compare with hash of known nonReentrant modifier instead of the name
-        if "nonReentrant" in [m.name for m in self.modifiers] or "nonreentrant(lock)" in [
-            m.name for m in self.modifiers
-        ]:
+        if reentrancy_modifier in [m.name for m in self.modifiers]:
             return False
 
         if self.visibility in ["public", "external"]:
@@ -1515,7 +1573,9 @@ class Function(SourceMapping, metaclass=ABCMeta):  # pylint: disable=too-many-pu
         ]
         if not all_entry_points:
             return True
-        return not all(("nonReentrant" in [m.name for m in f.modifiers] for f in all_entry_points))
+        return not all(
+            (reentrancy_modifier in [m.name for m in f.modifiers] for f in all_entry_points)
+        )
 
     # endregion
     ###################################################################################
@@ -1530,7 +1590,7 @@ class Function(SourceMapping, metaclass=ABCMeta):  # pylint: disable=too-many-pu
         write_var = [x for x in write_var if x]
         write_var = [item for sublist in write_var for item in sublist]
         write_var = list(set(write_var))
-        # Remove dupplicate if they share the same string representation
+        # Remove duplicate if they share the same string representation
         write_var = [
             next(obj)
             for i, obj in groupby(sorted(write_var, key=lambda x: str(x)), lambda x: str(x))
@@ -1541,7 +1601,7 @@ class Function(SourceMapping, metaclass=ABCMeta):  # pylint: disable=too-many-pu
         write_var = [x for x in write_var if x]
         write_var = [item for sublist in write_var for item in sublist]
         write_var = list(set(write_var))
-        # Remove dupplicate if they share the same string representation
+        # Remove duplicate if they share the same string representation
         write_var = [
             next(obj)
             for i, obj in groupby(sorted(write_var, key=lambda x: str(x)), lambda x: str(x))
@@ -1551,7 +1611,7 @@ class Function(SourceMapping, metaclass=ABCMeta):  # pylint: disable=too-many-pu
         read_var = [x.variables_read_as_expression for x in self.nodes]
         read_var = [x for x in read_var if x]
         read_var = [item for sublist in read_var for item in sublist]
-        # Remove dupplicate if they share the same string representation
+        # Remove duplicate if they share the same string representation
         read_var = [
             next(obj)
             for i, obj in groupby(sorted(read_var, key=lambda x: str(x)), lambda x: str(x))
@@ -1561,7 +1621,7 @@ class Function(SourceMapping, metaclass=ABCMeta):  # pylint: disable=too-many-pu
         read_var = [x.variables_read for x in self.nodes]
         read_var = [x for x in read_var if x]
         read_var = [item for sublist in read_var for item in sublist]
-        # Remove dupplicate if they share the same string representation
+        # Remove duplicate if they share the same string representation
         read_var = [
             next(obj)
             for i, obj in groupby(sorted(read_var, key=lambda x: str(x)), lambda x: str(x))

slither/core/declarations/function_contract.py

@@ -65,7 +65,10 @@ class FunctionContract(Function, ContractLevel):
 
     @property
     def file_scope(self) -> "FileScope":
-        return self.contract.file_scope
+        # This is the contract declarer's file scope because inherited functions have access
+        # to the file scope which their declared in. This scope may contain references not
+        # available in the child contract's scope. See inherited_function_scope.sol for an example.
+        return self.contract_declarer.file_scope
 
     # endregion
     ###################################################################################

slither/core/declarations/function_top_level.py

@@ -1,10 +1,11 @@
 """
     Function module
 """
-from typing import Dict, List, Tuple, TYPE_CHECKING
+from typing import Dict, List, Tuple, TYPE_CHECKING, Optional
 
 from slither.core.declarations import Function
 from slither.core.declarations.top_level import TopLevel
+from slither.utils.using_for import USING_FOR, merge_using_for
 
 if TYPE_CHECKING:
     from slither.core.compilation_unit import SlitherCompilationUnit
@@ -16,11 +17,25 @@ class FunctionTopLevel(Function, TopLevel):
     def __init__(self, compilation_unit: "SlitherCompilationUnit", scope: "FileScope") -> None:
         super().__init__(compilation_unit)
         self._scope: "FileScope" = scope
+        self._using_for_complete: Optional[USING_FOR] = None
 
     @property
     def file_scope(self) -> "FileScope":
         return self._scope
 
+    @property
+    def using_for_complete(self) -> USING_FOR:
+        """
+        USING_FOR: Dict of top level directive
+        """
+
+        if self._using_for_complete is None:
+            result = {}
+            for uftl in self.file_scope.using_for_directives:
+                result = merge_using_for(result, uftl.using_for)
+            self._using_for_complete = result
+        return self._using_for_complete
+
     @property
     def canonical_name(self) -> str:
         """

slither/core/declarations/import_directive.py

@@ -11,11 +11,13 @@ class Import(SourceMapping):
     def __init__(self, filename: Path, scope: "FileScope") -> None:
         super().__init__()
         self._filename: Path = filename
-        self._alias: Optional[str] = None
         self.scope: "FileScope" = scope
+        self._alias: Optional[str] = None
         # Map local name -> original name
         self.renaming: Dict[str, str] = {}
 
+        self._pattern = "import"
+
     @property
     def filename(self) -> str:
         """

slither/core/declarations/pragma_directive.py

@@ -11,6 +11,7 @@ class Pragma(SourceMapping):
         super().__init__()
         self._directive = directive
         self.scope: "FileScope" = scope
+        self._pattern = "pragma"
 
     @property
     def directive(self) -> List[str]:

slither/core/declarations/solidity_variables.py

@@ -21,7 +21,8 @@ SOLIDITY_VARIABLES = {
 }
 
 SOLIDITY_VARIABLES_COMPOSED = {
-    "block.basefee": "uint",
+    "block.basefee": "uint256",
+    "block.blobbasefee": "uint256",
     "block.coinbase": "address",
     "block.difficulty": "uint256",
     "block.prevrandao": "uint256",
@@ -44,6 +45,7 @@ SOLIDITY_VARIABLES_COMPOSED = {
 }
 
 SOLIDITY_FUNCTIONS: Dict[str, List[str]] = {
+    "blobhash(uint256)": ["bytes32"],
     "gasleft()": ["uint256"],
     "assert(bool)": [],
     "require(bool)": [],
@@ -114,6 +116,7 @@ SOLIDITY_FUNCTIONS: Dict[str, List[str]] = {
     "_abi_encode()": [],
     "slice()": [],
     "uint2str()": ["string"],
+    "send()": [],
 }
 
 
@@ -137,7 +140,7 @@ class SolidityVariable(SourceMapping):
         self._name = name
 
     # dev function, will be removed once the code is stable
-    def _check_name(self, name: str) -> None:  # pylint: disable=no-self-use
+    def _check_name(self, name: str) -> None:
         assert name in SOLIDITY_VARIABLES or name.endswith(("_slot", "_offset"))
 
     @property

slither/core/declarations/using_for_top_level.py

@@ -1,8 +1,7 @@
-from typing import TYPE_CHECKING, List, Dict, Union
+from typing import TYPE_CHECKING
 
-from slither.core.declarations.contract import USING_FOR_KEY, USING_FOR_ITEM
-from slither.core.solidity_types.type import Type
 from slither.core.declarations.top_level import TopLevel
+from slither.utils.using_for import USING_FOR
 
 if TYPE_CHECKING:
     from slither.core.scope.scope import FileScope
@@ -11,9 +10,9 @@ if TYPE_CHECKING:
 class UsingForTopLevel(TopLevel):
     def __init__(self, scope: "FileScope") -> None:
         super().__init__()
-        self._using_for: Dict[Union[str, Type], List[Type]] = {}
+        self._using_for: USING_FOR = {}
         self.file_scope: "FileScope" = scope
 
     @property
-    def using_for(self) -> Dict[USING_FOR_KEY, USING_FOR_ITEM]:
+    def using_for(self) -> USING_FOR:
         return self._using_for

slither/core/expressions/identifier.py

@@ -78,3 +78,6 @@ class Identifier(Expression):
 
     def __str__(self) -> str:
         return str(self._value)
+
+    def expression(self):
+        return self

slither/core/scope/scope.py

@@ -7,6 +7,7 @@ from crytic_compile.utils.naming import Filename
 from slither.core.declarations import Contract, Import, Pragma
 from slither.core.declarations.custom_error_top_level import CustomErrorTopLevel
 from slither.core.declarations.enum_top_level import EnumTopLevel
+from slither.core.declarations.event_top_level import EventTopLevel
 from slither.core.declarations.function_top_level import FunctionTopLevel
 from slither.core.declarations.using_for_top_level import UsingForTopLevel
 from slither.core.declarations.structure_top_level import StructureTopLevel
@@ -28,6 +29,7 @@ class FileScope:
     def __init__(self, filename: Filename) -> None:
         self.filename = filename
         self.accessible_scopes: List[FileScope] = []
+        self.exported_symbols: Set[int] = set()
 
         self.contracts: Dict[str, Contract] = {}
         # Custom error are a list instead of a dict
@@ -39,6 +41,7 @@ class FileScope:
         # Because we parse the function signature later on
         # So we simplify the logic and have the scope fields all populated
         self.functions: Set[FunctionTopLevel] = set()
+        self.events: Set[EventTopLevel] = set()
         self.using_for_directives: Set[UsingForTopLevel] = set()
         self.imports: Set[Import] = set()
         self.pragmas: Set[Pragma] = set()
@@ -54,50 +57,39 @@ class FileScope:
         # Name -> type alias
         self.type_aliases: Dict[str, TypeAlias] = {}
 
-    def add_accesible_scopes(self) -> bool:
+    def add_accessible_scopes(self) -> bool:  # pylint: disable=too-many-branches
         """
         Add information from accessible scopes. Return true if new information was obtained
-
         :return:
         :rtype:
         """
 
         learn_something = False
-
         for new_scope in self.accessible_scopes:
-            if not _dict_contain(new_scope.contracts, self.contracts):
-                self.contracts.update(new_scope.contracts)
-                learn_something = True
-            if not new_scope.custom_errors.issubset(self.custom_errors):
-                self.custom_errors |= new_scope.custom_errors
-                learn_something = True
-            if not _dict_contain(new_scope.enums, self.enums):
-                self.enums.update(new_scope.enums)
-                learn_something = True
-            if not new_scope.functions.issubset(self.functions):
-                self.functions |= new_scope.functions
-                learn_something = True
+            # To support using for directives on user defined types and user defined functions,
+            # we need to propagate the using for directives from the imported file to the importing file
+            # since it is not reflected in the "exportedSymbols" field of the AST.
             if not new_scope.using_for_directives.issubset(self.using_for_directives):
                 self.using_for_directives |= new_scope.using_for_directives
                 learn_something = True
-            if not new_scope.imports.issubset(self.imports):
-                self.imports |= new_scope.imports
-                learn_something = True
-            if not new_scope.pragmas.issubset(self.pragmas):
-                self.pragmas |= new_scope.pragmas
+            if not _dict_contain(new_scope.type_aliases, self.type_aliases):
+                self.type_aliases.update(new_scope.type_aliases)
                 learn_something = True
-            if not _dict_contain(new_scope.structures, self.structures):
-                self.structures.update(new_scope.structures)
+            if not new_scope.functions.issubset(self.functions):
+                self.functions |= new_scope.functions
                 learn_something = True
-            if not _dict_contain(new_scope.variables, self.variables):
-                self.variables.update(new_scope.variables)
+
+            # To get around this bug for aliases https://github.com/ethereum/solidity/pull/11881,
+            # we propagate the exported_symbols from the imported file to the importing file
+            # See tests/e2e/solc_parsing/test_data/top-level-nested-import-0.7.1.sol
+            if not new_scope.exported_symbols.issubset(self.exported_symbols):
+                self.exported_symbols |= new_scope.exported_symbols
                 learn_something = True
+
+            # This is need to support aliasing when we do a late lookup using SolidityImportPlaceholder
             if not _dict_contain(new_scope.renaming, self.renaming):
                 self.renaming.update(new_scope.renaming)
                 learn_something = True
-            if not _dict_contain(new_scope.type_aliases, self.type_aliases):
-                self.type_aliases.update(new_scope.type_aliases)
-                learn_something = True
 
         return learn_something
 

slither/core/slither_core.py

@@ -22,7 +22,7 @@ from slither.core.source_mapping.source_mapping import SourceMapping, Source
 from slither.slithir.variables import Constant
 from slither.utils.colors import red
 from slither.utils.sarif import read_triage_info
-from slither.utils.source_mapping import get_definition, get_references, get_implementation
+from slither.utils.source_mapping import get_definition, get_references, get_all_implementations
 
 logger = logging.getLogger("Slither")
 logging.basicConfig()
@@ -62,6 +62,7 @@ class SlitherCore(Context):
         # Multiple time the same result, so we remove duplicates
         self._currently_seen_resuts: Set[str] = set()
         self._paths_to_filter: Set[str] = set()
+        self._paths_to_include: Set[str] = set()
 
         self._crytic_compile: Optional[CryticCompile] = None
 
@@ -203,41 +204,53 @@ class SlitherCore(Context):
     def _compute_offsets_from_thing(self, thing: SourceMapping):
         definition = get_definition(thing, self.crytic_compile)
         references = get_references(thing)
-        implementation = get_implementation(thing)
+        implementations = get_all_implementations(thing, self.contracts)
 
         for offset in range(definition.start, definition.end + 1):
-
             if (
-                isinstance(thing, TopLevel)
+                isinstance(thing, (TopLevel, Contract))
                 or (
                     isinstance(thing, FunctionContract)
                     and thing.contract_declarer == thing.contract
                 )
                 or (isinstance(thing, ContractLevel) and not isinstance(thing, FunctionContract))
             ):
+
                 self._offset_to_objects[definition.filename][offset].add(thing)
 
             self._offset_to_definitions[definition.filename][offset].add(definition)
-            self._offset_to_implementations[definition.filename][offset].add(implementation)
+            self._offset_to_implementations[definition.filename][offset].update(implementations)
             self._offset_to_references[definition.filename][offset] |= set(references)
 
         for ref in references:
             for offset in range(ref.start, ref.end + 1):
-
+                is_declared_function = (
+                    isinstance(thing, FunctionContract)
+                    and thing.contract_declarer == thing.contract
+                )
                 if (
                     isinstance(thing, TopLevel)
-                    or (
-                        isinstance(thing, FunctionContract)
-                        and thing.contract_declarer == thing.contract
-                    )
+                    or is_declared_function
                     or (
                         isinstance(thing, ContractLevel) and not isinstance(thing, FunctionContract)
                     )
                 ):
                     self._offset_to_objects[definition.filename][offset].add(thing)
 
-                self._offset_to_definitions[ref.filename][offset].add(definition)
-                self._offset_to_implementations[ref.filename][offset].add(implementation)
+                if is_declared_function:
+                    # Only show the nearest lexical definition for declared contract-level functions
+                    if (
+                        thing.contract.source_mapping.start
+                        < offset
+                        < thing.contract.source_mapping.end
+                    ):
+
+                        self._offset_to_definitions[ref.filename][offset].add(definition)
+
+                else:
+                    self._offset_to_definitions[ref.filename][offset].add(definition)
+
+                self._offset_to_implementations[ref.filename][offset].update(implementations)
                 self._offset_to_references[ref.filename][offset] |= set(references)
 
     def _compute_offsets_to_ref_impl_decl(self):  # pylint: disable=too-many-branches
@@ -250,15 +263,18 @@ class SlitherCore(Context):
             for contract in compilation_unit.contracts:
                 self._compute_offsets_from_thing(contract)
 
-                for function in contract.functions:
+                for function in contract.functions_declared:
                     self._compute_offsets_from_thing(function)
                     for variable in function.local_variables:
                         self._compute_offsets_from_thing(variable)
-                for modifier in contract.modifiers:
+                for modifier in contract.modifiers_declared:
                     self._compute_offsets_from_thing(modifier)
                     for variable in modifier.local_variables:
                         self._compute_offsets_from_thing(variable)
 
+                for var in contract.state_variables:
+                    self._compute_offsets_from_thing(var)
+
                 for st in contract.structures:
                     self._compute_offsets_from_thing(st)
 
@@ -267,12 +283,26 @@ class SlitherCore(Context):
 
                 for event in contract.events:
                     self._compute_offsets_from_thing(event)
+
+                for typ in contract.type_aliases:
+                    self._compute_offsets_from_thing(typ)
+
             for enum in compilation_unit.enums_top_level:
                 self._compute_offsets_from_thing(enum)
+            for event in compilation_unit.events_top_level:
+                self._compute_offsets_from_thing(event)
             for function in compilation_unit.functions_top_level:
                 self._compute_offsets_from_thing(function)
             for st in compilation_unit.structures_top_level:
                 self._compute_offsets_from_thing(st)
+            for var in compilation_unit.variables_top_level:
+                self._compute_offsets_from_thing(var)
+            for typ in compilation_unit.type_aliases.values():
+                self._compute_offsets_from_thing(typ)
+            for err in compilation_unit.custom_errors:
+                self._compute_offsets_from_thing(err)
+            for event in compilation_unit.events_top_level:
+                self._compute_offsets_from_thing(event)
             for import_directive in compilation_unit.import_directives:
                 self._compute_offsets_from_thing(import_directive)
             for pragma in compilation_unit.pragma_directives:
@@ -409,25 +439,29 @@ class SlitherCore(Context):
             if "source_mapping" in elem
         ]
 
-        # Use POSIX-style paths so that filter_paths works across different
+        # Use POSIX-style paths so that filter_paths|include_paths works across different
         # OSes. Convert to a list so elements don't get consumed and are lost
         # while evaluating the first pattern
         source_mapping_elements = list(
             map(lambda x: pathlib.Path(x).resolve().as_posix() if x else x, source_mapping_elements)
         )
-        matching = False
+        (matching, paths, msg_err) = (
+            (True, self._paths_to_include, "--include-paths")
+            if self._paths_to_include
+            else (False, self._paths_to_filter, "--filter-paths")
+        )
 
-        for path in self._paths_to_filter:
+        for path in paths:
             try:
                 if any(
                     bool(re.search(_relative_path_format(path), src_mapping))
                     for src_mapping in source_mapping_elements
                 ):
-                    matching = True
+                    matching = not matching
                     break
             except re.error:
                 logger.error(
-                    f"Incorrect regular expression for --filter-paths {path}."
+                    f"Incorrect regular expression for {msg_err} {path}."
                     "\nSlither supports the Python re format"
                     ": https://docs.python.org/3/library/re.html"
                 )
@@ -498,6 +532,13 @@ class SlitherCore(Context):
         """
         self._paths_to_filter.add(path)
 
+    def add_path_to_include(self, path: str):
+        """
+        Add path to include
+        Path are used through direct comparison (no regex)
+        """
+        self._paths_to_include.add(path)
+
     # endregion
     ###################################################################################
     ###################################################################################

slither/core/solidity_types/array_type.py

@@ -74,7 +74,7 @@ class ArrayType(Type):
     def __eq__(self, other: Any) -> bool:
         if not isinstance(other, ArrayType):
             return False
-        return self._type == other.type and self.length == other.length
+        return self._type == other.type and self._length_value == other.length_value
 
     def __hash__(self) -> int:
         return hash(str(self))

slither/core/solidity_types/elementary_type.py

@@ -225,4 +225,4 @@ class ElementaryType(Type):
         return self.type == other.type
 
     def __hash__(self) -> int:
-        return hash(str(self))
+        return hash(self._type)

slither/core/solidity_types/type_alias.py

@@ -15,6 +15,7 @@ class TypeAlias(Type):
         super().__init__()
         self.name = name
         self.underlying_type = underlying_type
+        self._pattern = "type"
 
     @property
     def type(self) -> ElementaryType:

slither/core/source_mapping/source_mapping.py

@@ -1,5 +1,4 @@
 import re
-from abc import ABCMeta
 from typing import Dict, Union, List, Tuple, TYPE_CHECKING, Optional, Any
 
 from Crypto.Hash import SHA1
@@ -99,21 +98,29 @@ class Source:
         return f"{filename_short}{lines}"
 
     def __hash__(self) -> int:
-        return hash(str(self))
+        return hash(
+            (
+                self.start,
+                self.length,
+                self.filename.relative,
+                self.end,
+            )
+        )
 
     def __eq__(self, other: Any) -> bool:
-        if not isinstance(other, type(self)):
+        try:
+            return (
+                self.start == other.start
+                and self.length == other.length
+                and self.filename == other.filename
+                and self.is_dependency == other.is_dependency
+                and self.lines == other.lines
+                and self.starting_column == other.starting_column
+                and self.ending_column == other.ending_column
+                and self.end == other.end
+            )
+        except AttributeError:
             return NotImplemented
-        return (
-            self.start == other.start
-            and self.length == other.length
-            and self.filename == other.filename
-            and self.is_dependency == other.is_dependency
-            and self.lines == other.lines
-            and self.starting_column == other.starting_column
-            and self.ending_column == other.ending_column
-            and self.end == other.end
-        )
 
 
 def _compute_line(
@@ -183,12 +190,14 @@ def _convert_source_mapping(
     return new_source
 
 
-class SourceMapping(Context, metaclass=ABCMeta):
+class SourceMapping(Context):
     def __init__(self) -> None:
         super().__init__()
         self.source_mapping: Optional[Source] = None
         self.references: List[Source] = []
 
+        self._pattern: Union[str, None] = None
+
     def set_offset(
         self, offset: Union["Source", str], compilation_unit: "SlitherCompilationUnit"
     ) -> None:
@@ -204,3 +213,11 @@ class SourceMapping(Context, metaclass=ABCMeta):
     ) -> None:
         s = _convert_source_mapping(offset, compilation_unit)
         self.references.append(s)
+
+    @property
+    def pattern(self) -> str:
+        if self._pattern is None:
+            # Add " " to look after the first solidity keyword
+            return f" {self.name}"  # pylint: disable=no-member
+
+        return self._pattern

slither/core/variables/variable.py

@@ -93,6 +93,13 @@ class Variable(SourceMapping):
     def is_constant(self, is_cst: bool) -> None:
         self._is_constant = is_cst
 
+    @property
+    def is_stored(self) -> bool:
+        """
+        Checks if a variable is stored, based on it not being constant or immutable. Future updates may adjust for new non-storage keywords.
+        """
+        return not self._is_constant and not self._is_immutable
+
     @property
     def is_reentrant(self) -> bool:
         return self._is_reentrant

slither/detectors/all_detectors.py

@@ -97,3 +97,5 @@ from .assembly.return_instead_of_leave import ReturnInsteadOfLeave
 from .operations.incorrect_exp import IncorrectOperatorExponentiation
 from .statements.tautological_compare import TautologicalCompare
 from .statements.return_bomb import ReturnBomb
+from .functions.out_of_order_retryable import OutOfOrderRetryable
+from .statements.unused_import import UnusedImport

slither/detectors/assembly/incorrect_return.py

@@ -39,7 +39,9 @@ class IncorrectReturn(AbstractDetector):
     IMPACT = DetectorClassification.HIGH
     CONFIDENCE = DetectorClassification.MEDIUM
 
-    WIKI = "https://github.com/crytic/slither/wiki/Detector-Documentation#incorrect-assembly-return"
+    WIKI = (
+        "https://github.com/crytic/slither/wiki/Detector-Documentation#incorrect-return-in-assembly"
+    )
 
     WIKI_TITLE = "Incorrect return in assembly"
     WIKI_DESCRIPTION = "Detect if `return` in an assembly block halts unexpectedly the execution."

slither/detectors/assembly/return_instead_of_leave.py

@@ -20,7 +20,7 @@ class ReturnInsteadOfLeave(AbstractDetector):
     IMPACT = DetectorClassification.HIGH
     CONFIDENCE = DetectorClassification.MEDIUM
 
-    WIKI = "https://github.com/crytic/slither/wiki/Detector-Documentation#incorrect-assembly-return"
+    WIKI = "https://github.com/crytic/slither/wiki/Detector-Documentation#return-instead-of-leave-in-assembly"
 
     WIKI_TITLE = "Return instead of leave in assembly"
     WIKI_DESCRIPTION = "Detect if a `return` is used where a `leave` should be used."

slither/detectors/assembly/shift_parameter_mixup.py

@@ -8,6 +8,7 @@ from slither.slithir.operations import Binary, BinaryType
 from slither.slithir.variables import Constant
 from slither.core.declarations.function_contract import FunctionContract
 from slither.utils.output import Output
+from slither.core.cfg.node import NodeType
 
 
 class ShiftParameterMixup(AbstractDetector):
@@ -45,8 +46,18 @@ The shift statement will right-shift the constant 8 by `a` bits"""
 
     def _check_function(self, f: FunctionContract) -> List[Output]:
         results = []
+        in_assembly = False
 
         for node in f.nodes:
+            if node.type == NodeType.ASSEMBLY:
+                in_assembly = True
+                continue
+            if node.type == NodeType.ENDASSEMBLY:
+                in_assembly = False
+                continue
+            if not in_assembly:
+                continue
+
             for ir in node.irs:
                 if isinstance(ir, Binary) and ir.type in [
                     BinaryType.LEFT_SHIFT,

slither/detectors/attributes/constant_pragma.py

@@ -1,6 +1,7 @@
 """
     Check that the same pragma is used in all the files
 """
+from collections import OrderedDict
 from typing import List, Dict
 
 from slither.core.compilation_unit import SlitherCompilationUnit
@@ -31,16 +32,25 @@ class ConstantPragma(AbstractDetector):
 
     def _detect(self) -> List[Output]:
         results = []
-        pragma = self.compilation_unit.pragma_directives
-        versions = [p.version for p in pragma if p.is_solidity_version]
-        versions = sorted(list(set(versions)))
-
+        pragma_directives_by_version = OrderedDict()
+        for pragma in self.compilation_unit.pragma_directives:
+            if pragma.is_solidity_version:
+                if pragma.version not in pragma_directives_by_version:
+                    pragma_directives_by_version[
+                        pragma.version
+                    ] = f"\t\t- {str(pragma.source_mapping)}\n"
+                else:
+                    pragma_directives_by_version[
+                        pragma.version
+                    ] += f"\t\t- {str(pragma.source_mapping)}\n"
+
+        versions = list(pragma_directives_by_version.keys())
         if len(versions) > 1:
-            info: DETECTOR_INFO = ["Different versions of Solidity are used:\n"]
-            info += [f"\t- Version used: {[str(v) for v in versions]}\n"]
+            info: DETECTOR_INFO = [f"{len(versions)} different versions of Solidity are used:\n"]
 
-            for p in sorted(pragma, key=lambda x: x.version):
-                info += ["\t- ", p, "\n"]
+            for version in versions:
+                pragma = pragma_directives_by_version[version]
+                info += [f"\t- Version constraint {version} is used by:\n {pragma}"]
 
             res = self.generate_result(info)
 

slither/detectors/attributes/incorrect_solc.py

@@ -12,6 +12,7 @@ from slither.detectors.abstract_detector import (
 )
 from slither.formatters.attributes.incorrect_solc import custom_format
 from slither.utils.output import Output
+from slither.utils.buggy_versions import bugs_by_version
 
 # group:
 # 0: ^ > >= < <= (optional)
@@ -46,64 +47,36 @@ We also recommend avoiding complex `pragma` statement."""
 
     # region wiki_recommendation
     WIKI_RECOMMENDATION = """
-Deploy with any of the following Solidity versions:
-- 0.8.18
-
-The recommendations take into account:
-- Risks related to recent releases
-- Risks of complex code generation changes
-- Risks of new language features
-- Risks of known bugs
+Deploy with a recent version of Solidity (at least 0.8.0) with no known severe issues.
 
 Use a simple pragma version that allows any of these versions.
 Consider using the latest version of Solidity for testing."""
     # endregion wiki_recommendation
 
     COMPLEX_PRAGMA_TXT = "is too complex"
-    OLD_VERSION_TXT = "allows old versions"
+    OLD_VERSION_TXT = (
+        "is an outdated solc version. Use a more recent version (at least 0.8.0), if possible."
+    )
     LESS_THAN_TXT = "uses lesser than"
 
     BUGGY_VERSION_TXT = (
-        "is known to contain severe issues (https://solidity.readthedocs.io/en/latest/bugs.html)"
+        "contains known severe issues (https://solidity.readthedocs.io/en/latest/bugs.html)"
     )
 
     # Indicates the allowed versions. Must be formatted in increasing order.
-    ALLOWED_VERSIONS = ["0.8.18"]
-
-    TOO_RECENT_VERSION_TXT = f"necessitates a version too recent to be trusted. Consider deploying with {'/'.join(ALLOWED_VERSIONS)}."
-
-    # Indicates the versions that should not be used.
-    BUGGY_VERSIONS = [
-        "0.4.22",
-        "^0.4.22",
-        "0.5.5",
-        "^0.5.5",
-        "0.5.6",
-        "^0.5.6",
-        "0.5.14",
-        "^0.5.14",
-        "0.6.9",
-        "^0.6.9",
-        "0.8.8",
-        "^0.8.8",
-    ]
+    ALLOWED_VERSIONS = ["0.8.0"]
 
     def _check_version(self, version: Tuple[str, str, str, str, str]) -> Optional[str]:
         op = version[0]
         if op and op not in [">", ">=", "^"]:
             return self.LESS_THAN_TXT
         version_number = ".".join(version[2:])
-        if version_number in self.BUGGY_VERSIONS:
-            return self.BUGGY_VERSION_TXT
-        if version_number not in self.ALLOWED_VERSIONS:
-            if list(map(int, version[2:])) > list(map(int, self.ALLOWED_VERSIONS[-1].split("."))):
-                return self.TOO_RECENT_VERSION_TXT
-            return self.OLD_VERSION_TXT
+        if version_number in bugs_by_version:
+            bugs = "\n".join([f"\t- {bug}" for bug in bugs_by_version[version_number]])
+            return self.BUGGY_VERSION_TXT + f"\n{bugs}"
         return None
 
     def _check_pragma(self, version: str) -> Optional[str]:
-        if version in self.BUGGY_VERSIONS:
-            return self.BUGGY_VERSION_TXT
         versions = PATTERN.findall(version)
         if len(versions) == 1:
             version = versions[0]
@@ -130,42 +103,43 @@ Consider using the latest version of Solidity for testing."""
         # Detect all version related pragmas and check if they are disallowed.
         results = []
         pragma = self.compilation_unit.pragma_directives
-        disallowed_pragmas = []
+        disallowed_pragmas = {}
 
         for p in pragma:
             # Skip any pragma directives which do not refer to version
             if len(p.directive) < 1 or p.directive[0] != "solidity":
                 continue
 
-            # This is version, so we test if this is disallowed.
             reason = self._check_pragma(p.version)
-            if reason:
-                disallowed_pragmas.append((reason, p))
+            if reason is None:
+                continue
+
+            if p.version in disallowed_pragmas and reason in disallowed_pragmas[p.version]:
+                disallowed_pragmas[p.version][reason] += f"\t- {str(p.source_mapping)}\n"
+            else:
+                disallowed_pragmas[p.version] = {reason: f"\t- {str(p.source_mapping)}\n"}
 
         # If we found any disallowed pragmas, we output our findings.
-        if disallowed_pragmas:
-            for (reason, p) in disallowed_pragmas:
-                info: DETECTOR_INFO = ["Pragma version", p, f" {reason}\n"]
+        if len(disallowed_pragmas.keys()):
+            for p, reasons in disallowed_pragmas.items():
+                info: DETECTOR_INFO = []
+                for r, v in reasons.items():
+                    info += [f"Version constraint {p} {r}.\n It is used by:\n{v}"]
 
                 json = self.generate_result(info)
 
                 results.append(json)
 
-        if self.compilation_unit.solc_version not in self.ALLOWED_VERSIONS:
-
-            if self.compilation_unit.solc_version in self.BUGGY_VERSIONS:
-                info = [
-                    "solc-",
-                    self.compilation_unit.solc_version,
-                    " ",
-                    self.BUGGY_VERSION_TXT,
-                ]
-            else:
-                info = [
-                    "solc-",
-                    self.compilation_unit.solc_version,
-                    " is not recommended for deployment\n",
-                ]
+        if list(map(int, self.compilation_unit.solc_version.split("."))) < list(
+            map(int, self.ALLOWED_VERSIONS[-1].split("."))
+        ):
+            info = [
+                "solc-",
+                self.compilation_unit.solc_version,
+                " ",
+                self.OLD_VERSION_TXT,
+                "\n",
+            ]
 
             json = self.generate_result(info)
 

slither/detectors/compiler_bugs/reused_base_constructor.py

@@ -35,7 +35,7 @@ class ReusedBaseConstructor(AbstractDetector):
     ARGUMENT = "reused-constructor"
     HELP = "Reused base constructor"
     IMPACT = DetectorClassification.MEDIUM
-    # The confidence is medium, because prior Solidity 0.4.22, we cant differentiate
+    # The confidence is medium, because prior Solidity 0.4.22, we can't differentiate
     # contract C is A() {
     # to
     # contract C is A {

slither/detectors/functions/modifier.py

@@ -89,7 +89,7 @@ If the condition in `myModif` is false, the execution of `get()` will return 0."
                     info: DETECTOR_INFO = [
                         "Modifier ",
                         mod,
-                        " does not always execute _; or revert",
+                        " does not always execute _; or revert\n",
                     ]
 
                     res = self.generate_result(info)

slither/detectors/functions/out_of_order_retryable.py

@@ -0,0 +1,155 @@
+from typing import List
+
+from slither.core.cfg.node import Node
+from slither.core.declarations import Function, FunctionContract
+from slither.slithir.operations import HighLevelCall
+from slither.detectors.abstract_detector import AbstractDetector, DetectorClassification
+from slither.utils.output import Output
+
+
+class OutOfOrderRetryable(AbstractDetector):
+
+    ARGUMENT = "out-of-order-retryable"
+    HELP = "Out-of-order retryable transactions"
+    IMPACT = DetectorClassification.MEDIUM
+    CONFIDENCE = DetectorClassification.MEDIUM
+
+    WIKI = "https://github.com/crytic/slither/wiki/Detector-Documentation#out-of-order-retryable-transactions"
+
+    WIKI_TITLE = "Out-of-order retryable transactions"
+    WIKI_DESCRIPTION = "Out-of-order retryable transactions"
+
+    # region wiki_exploit_scenario
+    WIKI_EXPLOIT_SCENARIO = """
+```solidity
+contract L1 {
+    function doStuffOnL2() external {
+        // Retryable A
+        IInbox(inbox).createRetryableTicket({
+            to: l2contract,
+            l2CallValue: 0,
+            maxSubmissionCost: maxSubmissionCost,
+            excessFeeRefundAddress: msg.sender,
+            callValueRefundAddress: msg.sender,
+            gasLimit: gasLimit,
+            maxFeePerGas: maxFeePerGas,
+            data: abi.encodeCall(l2contract.claim_rewards, ())
+        });
+        // Retryable B
+        IInbox(inbox).createRetryableTicket({
+            to: l2contract,
+            l2CallValue: 0,
+            maxSubmissionCost: maxSubmissionCost,
+            excessFeeRefundAddress: msg.sender,
+            callValueRefundAddress: msg.sender,
+            gasLimit: gas,
+            maxFeePerGas: maxFeePerGas,
+            data: abi.encodeCall(l2contract.unstake, ())
+        });
+    }
+}
+
+contract L2 {
+    function claim_rewards() public {
+        // rewards is computed based on balance and staking period
+        uint unclaimed_rewards = _compute_and_update_rewards();
+        token.safeTransfer(msg.sender, unclaimed_rewards);
+    }
+
+    // Call claim_rewards before unstaking, otherwise you lose your rewards
+    function unstake() public {
+        _free_rewards(); // clean up rewards related variables
+        balance = balance[msg.sender];
+        balance[msg.sender] = 0;
+        staked_token.safeTransfer(msg.sender, balance);
+    }
+}
+```
+Bob calls `doStuffOnL2` but the first retryable ticket calling `claim_rewards` fails. The second retryable ticket calling `unstake` is executed successfully. As a result, Bob loses his rewards."""
+    # endregion wiki_exploit_scenario
+
+    WIKI_RECOMMENDATION = "Do not rely on the order or successful execution of retryable tickets."
+
+    key = "OUTOFORDERRETRYABLE"
+
+    # pylint: disable=too-many-branches
+    def _detect_multiple_tickets(
+        self, function: FunctionContract, node: Node, visited: List[Node]
+    ) -> None:
+        if node in visited:
+            return
+
+        visited = visited + [node]
+
+        fathers_context = []
+
+        for father in node.fathers:
+            if self.key in father.context:
+                fathers_context += father.context[self.key]
+
+        # Exclude path that dont bring further information
+        if node in self.visited_all_paths:
+            if all(f_c in self.visited_all_paths[node] for f_c in fathers_context):
+                return
+        else:
+            self.visited_all_paths[node] = []
+
+        self.visited_all_paths[node] = self.visited_all_paths[node] + fathers_context
+
+        if self.key not in node.context:
+            node.context[self.key] = fathers_context
+
+        # include ops from internal function calls
+        internal_ops = []
+        for internal_call in node.internal_calls:
+            if isinstance(internal_call, Function):
+                internal_ops += internal_call.all_slithir_operations()
+
+        # analyze node for retryable tickets
+        for ir in node.irs + internal_ops:
+            if (
+                isinstance(ir, HighLevelCall)
+                and isinstance(ir.function, Function)
+                and ir.function.name
+                in [
+                    "createRetryableTicket",
+                    "outboundTransferCustomRefund",
+                    "unsafeCreateRetryableTicket",
+                ]
+            ):
+                node.context[self.key].append(node)
+
+        if len(node.context[self.key]) > 1:
+            self.results.append(node.context[self.key])
+            return
+
+        for son in node.sons:
+            self._detect_multiple_tickets(function, son, visited)
+
+    def _detect(self) -> List[Output]:
+        results = []
+
+        # pylint: disable=attribute-defined-outside-init
+        self.results = []
+        self.visited_all_paths = {}
+
+        for contract in self.compilation_unit.contracts:
+            for function in contract.functions:
+                if (
+                    function.is_implemented
+                    and function.contract_declarer == contract
+                    and function.entry_point
+                ):
+                    function.entry_point.context[self.key] = []
+                    self._detect_multiple_tickets(function, function.entry_point, [])
+
+        for multiple_tickets in self.results:
+            info = ["Multiple retryable tickets created in the same function:\n"]
+
+            for x in multiple_tickets:
+                info += ["\t -", x, "\n"]
+
+            json = self.generate_result(info)
+            results.append(json)
+
+        return results

slither/detectors/functions/suicidal.py

@@ -59,7 +59,7 @@ Bob calls `kill` and destructs the contract."""
         if func.visibility not in ["public", "external"]:
             return False
 
-        calls = [c.name for c in func.internal_calls]
+        calls = [c.name for c in func.all_internal_calls()]
         if not ("suicide(address)" in calls or "selfdestruct(address)" in calls):
             return False
 

slither/detectors/naming_convention/naming_convention.py

@@ -16,7 +16,7 @@ class NamingConvention(AbstractDetector):
 
     Exceptions:
     - Allow constant variables name/symbol/decimals to be lowercase (ERC20)
-    - Allow '_' at the beggining of the mixed_case match for private variables and unused parameters
+    - Allow '_' at the beginning of the mixed_case match for private variables and unused parameters
     - Ignore echidna properties (functions with names starting 'echidna_' or 'crytic_'
     """
 

slither/detectors/operations/unchecked_send_return_value.py

@@ -39,5 +39,5 @@ If `send` is used to prevent blocking operations, consider logging the failed `s
 
     WIKI_RECOMMENDATION = "Ensure that the return value of `send` is checked or logged."
 
-    def _is_instance(self, ir: Operation) -> bool:  # pylint: disable=no-self-use
+    def _is_instance(self, ir: Operation) -> bool:
         return isinstance(ir, Send)

slither/detectors/operations/unchecked_transfer.py

@@ -46,7 +46,7 @@ Several tokens do not revert in case of failure and return false. If one of thes
         "Use `SafeERC20`, or ensure that the transfer/transferFrom return value is checked."
     )
 
-    def _is_instance(self, ir: Operation) -> bool:  # pylint: disable=no-self-use
+    def _is_instance(self, ir: Operation) -> bool:
         return (
             isinstance(ir, HighLevelCall)
             and isinstance(ir.function, Function)

slither/detectors/operations/unused_return_values.py

@@ -49,7 +49,7 @@ contract MyConc{
 
     WIKI_RECOMMENDATION = "Ensure that all the return values of the function calls are used."
 
-    def _is_instance(self, ir: Operation) -> bool:  # pylint: disable=no-self-use
+    def _is_instance(self, ir: Operation) -> bool:
         return (
             isinstance(ir, HighLevelCall)
             and (
@@ -64,9 +64,7 @@ contract MyConc{
             and isinstance(ir, (Assignment, Unpack))
         )
 
-    def detect_unused_return_values(
-        self, f: FunctionContract
-    ) -> List[Node]:  # pylint: disable=no-self-use
+    def detect_unused_return_values(self, f: FunctionContract) -> List[Node]:
         """
             Return the nodes where the return value of a call is unused
         Args:

slither/detectors/slither/name_reused.py

@@ -1,6 +1,8 @@
 from collections import defaultdict
 from typing import List
 
+from crytic_compile.platform import Type as PlatformType
+
 from slither.core.compilation_unit import SlitherCompilationUnit
 from slither.core.declarations import Contract
 from slither.detectors.abstract_detector import (
@@ -61,6 +63,8 @@ As a result, the second contract cannot be analyzed.
     def _detect(self) -> List[Output]:
         results = []
         compilation_unit = self.compilation_unit
+        if compilation_unit.core.crytic_compile.platform != PlatformType.TRUFFLE:
+            return []
 
         all_contracts = compilation_unit.contracts
         all_contracts_name = [c.name for c in all_contracts]

slither/detectors/statements/divide_before_multiply.py

@@ -80,7 +80,7 @@ def _explore(
         for ir in node.irs:
             if isinstance(ir, Assignment):
                 if ir.rvalue in divisions:
-                    # Avoid dupplicate. We dont use set so we keep the order of the nodes
+                    # Avoid duplicate. We dont use set so we keep the order of the nodes
                     if node not in divisions[ir.rvalue]:  # type: ignore
                         divisions[ir.lvalue] = divisions[ir.rvalue] + [node]  # type: ignore
                     else:
@@ -94,7 +94,7 @@ def _explore(
                 nodes = []
                 for r in mul_arguments:
                     if not isinstance(r, Constant) and (r in divisions):
-                        # Dont add node already present to avoid dupplicate
+                        # Dont add node already present to avoid duplicate
                         # We dont use set to keep the order of the nodes
                         if node in divisions[r]:
                             nodes += [n for n in divisions[r] if n not in nodes]
@@ -133,7 +133,7 @@ def detect_divide_before_multiply(
     results: List[Tuple[FunctionContract, List[Node]]] = []
 
     # Loop for each function and modifier.
-    for function in contract.functions_declared:
+    for function in contract.functions_declared + contract.modifiers_declared:
         if not function.entry_point:
             continue
 

slither/detectors/statements/msg_value_in_loop.py

@@ -8,6 +8,9 @@ from slither.detectors.abstract_detector import (
 from slither.slithir.operations import InternalCall
 from slither.core.declarations import SolidityVariableComposed, Contract
 from slither.utils.output import Output
+from slither.slithir.variables.constant import Constant
+from slither.core.variables import Variable
+from slither.core.expressions.literal import Literal
 
 
 def detect_msg_value_in_loop(contract: Contract) -> List[Node]:
@@ -37,6 +40,21 @@ def msg_value_in_loop(
 
     for ir in node.all_slithir_operations():
         if in_loop_counter > 0 and SolidityVariableComposed("msg.value") in ir.read:
+            # If we find a conditional expression with msg.value and is compared to 0 we don't report it
+            if ir.node.is_conditional() and SolidityVariableComposed("msg.value") in ir.read:
+                compared_to = (
+                    ir.read[1]
+                    if ir.read[0] == SolidityVariableComposed("msg.value")
+                    else ir.read[0]
+                )
+                if (
+                    isinstance(compared_to, Constant)
+                    and compared_to.value == 0
+                    or isinstance(compared_to, Variable)
+                    and isinstance(compared_to.expression, Literal)
+                    and str(compared_to.expression.value) == "0"
+                ):
+                    continue
             results.append(ir.node)
         if isinstance(ir, (InternalCall)):
             msg_value_in_loop(ir.function.entry_point, in_loop_counter, visited, results)

slither/detectors/statements/too_many_digits.py

@@ -40,7 +40,7 @@ class TooManyDigits(AbstractDetector):
 
     # region wiki_description
     WIKI_DESCRIPTION = """
-Literals with many digits are difficult to read and review.
+Literals with many digits are difficult to read and review. Use scientific notation or suffixes to make the code more readable.
 """
     # endregion wiki_description
 

slither/detectors/statements/unused_import.py

@@ -0,0 +1,75 @@
+from typing import List
+from slither.detectors.abstract_detector import AbstractDetector, DetectorClassification, Output
+
+# pylint: disable=protected-access,too-many-nested-blocks
+class UnusedImport(AbstractDetector):
+    """
+    Detector unused imports.
+    """
+
+    ARGUMENT = "unused-import"
+    HELP = "Detects unused imports"
+    IMPACT = DetectorClassification.INFORMATIONAL
+    CONFIDENCE = DetectorClassification.HIGH
+
+    WIKI = "https://github.com/crytic/slither/wiki/Detector-Documentation#unused-imports"
+
+    WIKI_TITLE = "Unused Imports"
+    WIKI_DESCRIPTION = "Importing a file that is not used in the contract likely indicates a mistake. The import should be removed until it is needed."
+
+    # region wiki_exploit_scenario
+    WIKI_EXPLOIT_SCENARIO = """
+    ```solidity
+    import {A} from "./A.sol";
+    contract B {}
+    ```
+    B either should import from A and it was forgotten or the import is not needed and should be removed.
+    """
+    # endregion wiki_exploit_scenario
+    WIKI_RECOMMENDATION = (
+        "Remove the unused import. If the import is needed later, it can be added back."
+    )
+
+    def _detect(self) -> List[Output]:
+        results: List[Output] = []
+        # This is computed lazily and then memoized so we need to trigger the computation.
+        self.slither._compute_offsets_to_ref_impl_decl()
+
+        for unit in self.slither.compilation_units:
+            for filename, scope in unit.scopes.items():
+                unused = []
+                for i in scope.imports:
+                    # `scope.imports` contains all transitive imports so we need to filter out imports not explicitly imported in the file.
+                    # Otherwise, we would recommend removing an import that is used by a leaf contract and cause compilation errors.
+                    if i.scope != scope:
+                        continue
+
+                    import_path = self.slither.crytic_compile.filename_lookup(i.filename)
+
+                    use_found = False
+                    # Search through all references to the imported file
+                    for _, refs in self.slither._offset_to_references[import_path].items():
+                        for ref in refs:
+                            # If there is a reference in this file to the imported file, it is used.
+                            if ref.filename == filename:
+                                use_found = True
+                                break
+
+                        if use_found:
+                            break
+
+                    if not use_found:
+                        unused.append(f"{i.source_mapping.content} ({i.source_mapping})")
+
+                if len(unused) > 0:
+                    unused_list = "\n\t-" + "\n\t-".join(unused)
+
+                    results.append(
+                        self.generate_result(
+                            [
+                                f"The following unused import(s) in {filename.used} should be removed: {unused_list}\n",
+                            ]
+                        )
+                    )
+
+        return results

slither/detectors/variables/predeclaration_usage_local.py

@@ -36,7 +36,7 @@ class PredeclarationUsageLocal(AbstractDetector):
 ```solidity
 contract C {
     function f(uint z) public returns (uint) {
-        uint y = x + 9 + z; // 'z' is used pre-declaration
+        uint y = x + 9 + z; // 'x' is used pre-declaration
         uint x = 7;
 
         if (z % 2 == 0) {

slither/detectors/variables/unchanged_state_variables.py

@@ -25,7 +25,7 @@ def _is_valid_type(v: StateVariable) -> bool:
 
 
 def _valid_candidate(v: StateVariable) -> bool:
-    return _is_valid_type(v) and not (v.is_constant or v.is_immutable)
+    return _is_valid_type(v)
 
 
 def _is_constant_var(v: Variable) -> bool:
@@ -92,7 +92,7 @@ class UnchangedStateVariables:
             variables = []
             functions = []
 
-            variables.append(c.state_variables)
+            variables.append(c.stored_state_variables)
             functions.append(c.all_functions_called)
 
             valid_candidates: Set[StateVariable] = {

slither/detectors/variables/unused_state_variables.py

@@ -46,8 +46,18 @@ def detect_unused(contract: Contract) -> Optional[List[StateVariable]]:
     variables_used = [item for sublist in variables_used for item in sublist]
     variables_used = list(set(variables_used + array_candidates))
 
+    # If the contract is abstract, only consider private variables as other visibilities may be used in dependencies
+    if contract.is_abstract:
+        return [
+            x
+            for x in contract.state_variables
+            if x not in variables_used and x.visibility == "private"
+        ]
+
     # Return the variables unused that are not public
-    return [x for x in contract.variables if x not in variables_used and x.visibility != "public"]
+    return [
+        x for x in contract.state_variables if x not in variables_used and x.visibility != "public"
+    ]
 
 
 class UnusedStateVars(AbstractDetector):
@@ -71,7 +81,7 @@ class UnusedStateVars(AbstractDetector):
         """Detect unused state variables"""
         results = []
         for c in self.compilation_unit.contracts_derived:
-            if c.is_signature_only():
+            if c.is_signature_only() or c.is_library:
                 continue
             unusedVars = detect_unused(c)
             if unusedVars:

slither/formatters/naming_convention/naming_convention.py

@@ -501,7 +501,7 @@ def _explore_variables_declaration(  # pylint: disable=too-many-arguments,too-ma
 
                         idx_beginning = func.source_mapping.start
                         idx_beginning += -func.source_mapping.starting_column + 1
-                        idx_beginning += -sum([len(c) for c in potential_comments])
+                        idx_beginning += -sum(len(c) for c in potential_comments)
 
                         old_comment = f"@param {old_str}".encode("utf8")
 

slither/printers/abstract_printer.py

@@ -20,7 +20,7 @@ class AbstractPrinter(metaclass=abc.ABCMeta):
 
     WIKI = ""
 
-    def __init__(self, slither: "Slither", logger: Logger) -> None:
+    def __init__(self, slither: "Slither", logger: Optional[Logger]) -> None:
         self.slither = slither
         self.contracts = slither.contracts
         self.filename = slither.filename

slither/printers/inheritance/inheritance_graph.py

@@ -100,10 +100,11 @@ class PrinterInheritanceGraph(AbstractPrinter):
 
         # Add arrows (number them if there is more than one path so we know order of declaration for inheritance).
         if len(contract.immediate_inheritance) == 1:
-            ret += f"{contract.name} -> {contract.immediate_inheritance[0]};\n"
+            immediate_inheritance = contract.immediate_inheritance[0]
+            ret += f"c{contract.id}_{contract.name} -> c{immediate_inheritance.id}_{immediate_inheritance};\n"
         else:
             for i, immediate_inheritance in enumerate(contract.immediate_inheritance):
-                ret += f'{contract.name} -> {immediate_inheritance} [ label="{i + 1}" ];\n'
+                ret += f'c{contract.id}_{contract.name} -> c{immediate_inheritance.id}_{immediate_inheritance} [ label="{i + 1}" ];\n'
 
         # Functions
         visibilities = ["public", "external"]
@@ -151,7 +152,7 @@ class PrinterInheritanceGraph(AbstractPrinter):
         indirect_shadowing_information = self._get_indirect_shadowing_information(contract)
 
         # Build the node label
-        ret += f'{contract.name}[shape="box"'
+        ret += f'c{contract.id}_{contract.name}[shape="box"'
         ret += 'label=< <TABLE border="0">'
         ret += f'<TR><TD align="center"><B>{contract.name}</B></TD></TR>'
         if public_functions:

slither/printers/summary/declaration.py

@@ -21,18 +21,20 @@ class Declaration(AbstractPrinter):
             txt += "\n# Contracts\n"
             for contract in compilation_unit.contracts:
                 txt += f"# {contract.name}\n"
-                txt += f"\t- Declaration: {get_definition(contract, compilation_unit.core.crytic_compile).to_detailed_str()}\n"
-                txt += f"\t- Implementation: {get_implementation(contract).to_detailed_str()}\n"
+                contract_def = get_definition(contract, compilation_unit.core.crytic_compile)
+                txt += f"\t- Declaration: {contract_def.to_detailed_str()}\n"
+                txt += f"\t- Implementation(s): {[x.to_detailed_str() for x in list(self.slither.offset_to_implementations(contract.source_mapping.filename.absolute, contract_def.start))]}\n"
                 txt += (
                     f"\t- References: {[x.to_detailed_str() for x in get_references(contract)]}\n"
                 )
 
                 txt += "\n\t## Function\n"
 
-                for func in contract.functions:
+                for func in contract.functions_declared:
                     txt += f"\t\t- {func.canonical_name}\n"
-                    txt += f"\t\t\t- Declaration: {get_definition(func, compilation_unit.core.crytic_compile).to_detailed_str()}\n"
-                    txt += f"\t\t\t- Implementation: {get_implementation(func).to_detailed_str()}\n"
+                    function_def = get_definition(func, compilation_unit.core.crytic_compile)
+                    txt += f"\t\t\t- Declaration: {function_def.to_detailed_str()}\n"
+                    txt += f"\t\t\t- Implementation(s): {[x.to_detailed_str() for x in list(self.slither.offset_to_implementations(func.source_mapping.filename.absolute, function_def.start))]}\n"
                     txt += f"\t\t\t- References: {[x.to_detailed_str() for x in get_references(func)]}\n"
 
                 txt += "\n\t## State variables\n"

slither/printers/summary/evm.py

@@ -1,7 +1,12 @@
 """
     Module printing evm mapping of the contract
 """
+import logging
+from typing import Union, List, Dict
+
 from slither.printers.abstract_printer import AbstractPrinter
+from slither.core.declarations.function import Function
+from slither.core.declarations.modifier import Modifier
 from slither.analyses.evm import (
     generate_source_to_evm_ins_mapping,
     load_evm_cfg_builder,
@@ -9,6 +14,9 @@ from slither.analyses.evm import (
 from slither.utils.colors import blue, green, magenta, red
 
 
+logger: logging.Logger = logging.getLogger("EVMPrinter")
+
+
 def _extract_evm_info(slither):
     """
     Extract evm information for all derived contracts using evm_cfg_builder
@@ -24,6 +32,16 @@ def _extract_evm_info(slither):
         contract_bytecode_runtime = contract.file_scope.bytecode_runtime(
             contract.compilation_unit.crytic_compile_compilation_unit, contract.name
         )
+
+        if not contract_bytecode_runtime:
+            logger.info(
+                "Contract %s (abstract: %r) has no bytecode runtime, skipping. ",
+                contract.name,
+                contract.is_abstract,
+            )
+            evm_info["empty", contract.name] = True
+            continue
+
         contract_srcmap_runtime = contract.file_scope.srcmap_runtime(
             contract.compilation_unit.crytic_compile_compilation_unit, contract.name
         )
@@ -62,6 +80,33 @@ class PrinterEVM(AbstractPrinter):
 
     WIKI = "https://github.com/trailofbits/slither/wiki/Printer-documentation#evm"
 
+    def build_element_node_str(
+        self,
+        element: Union["Modifier", "Function"],
+        contract_pcs: Dict[int, List[int]],
+        contract_cfg,
+    ) -> str:
+        element_file = self.slither.source_code[
+            element.contract_declarer.source_mapping.filename.absolute
+        ].splitlines()
+
+        return_string = ""
+        for node in element.nodes:
+            return_string += green(f"\t\tNode: {node}\n")
+            node_source_line = node.source_mapping.lines[0]
+            return_string += green(
+                f"\t\tSource line {node_source_line}: {element_file[node_source_line - 1].rstrip()}\n"
+            )
+
+            return_string += magenta("\t\tEVM Instructions:\n")
+            node_pcs = contract_pcs.get(node_source_line, [])
+            for pc in node_pcs:
+                return_string += magenta(
+                    f"\t\t\t{hex(pc)}: {contract_cfg.get_instruction_at(pc)}\n"
+                )
+
+        return return_string
+
     def output(self, _filename):
         """
         _filename is not used
@@ -80,53 +125,31 @@ class PrinterEVM(AbstractPrinter):
         for contract in self.slither.contracts_derived:
             txt += blue(f"Contract {contract.name}\n")
 
-            contract_file = self.slither.source_code[
-                contract.source_mapping.filename.absolute
-            ].encode("utf-8")
-            with open(contract.source_mapping.filename.absolute, "r", encoding="utf8") as f:
-                contract_file_lines = f.readlines()
-
-            contract_pcs = {}
-            contract_cfg = {}
+            if evm_info.get(("empty", contract.name), False):
+                txt += "\tempty contract\n"
+                continue
 
             for function in contract.functions:
                 txt += blue(f"\tFunction {function.canonical_name}\n")
 
-                # CFG and source mapping depend on function being constructor or not
-                if function.is_constructor:
-                    contract_cfg = evm_info["cfg_init", contract.name]
-                    contract_pcs = evm_info["mapping_init", contract.name]
-                else:
-                    contract_cfg = evm_info["cfg", contract.name]
-                    contract_pcs = evm_info["mapping", contract.name]
-
-                for node in function.nodes:
-                    txt += green("\t\tNode: " + str(node) + "\n")
-                    node_source_line = (
-                        contract_file[0 : node.source_mapping.start].count("\n".encode("utf-8")) + 1
-                    )
-                    txt += green(
-                        f"\t\tSource line {node_source_line}: {contract_file_lines[node_source_line - 1].rstrip()}\n"
-                    )
-                    txt += magenta("\t\tEVM Instructions:\n")
-                    node_pcs = contract_pcs.get(node_source_line, [])
-                    for pc in node_pcs:
-                        txt += magenta(f"\t\t\t{hex(pc)}: {contract_cfg.get_instruction_at(pc)}\n")
+                txt += self.build_element_node_str(
+                    function,
+                    evm_info["mapping", contract.name]
+                    if not function.is_constructor
+                    else evm_info["mapping_init", contract.name],
+                    evm_info["cfg", contract.name]
+                    if not function.is_constructor
+                    else evm_info["cfg_init", contract.name],
+                )
 
             for modifier in contract.modifiers:
                 txt += blue(f"\tModifier {modifier.canonical_name}\n")
-                for node in modifier.nodes:
-                    txt += green("\t\tNode: " + str(node) + "\n")
-                    node_source_line = (
-                        contract_file[0 : node.source_mapping.start].count("\n".encode("utf-8")) + 1
-                    )
-                    txt += green(
-                        f"\t\tSource line {node_source_line}: {contract_file_lines[node_source_line - 1].rstrip()}\n"
-                    )
-                    txt += magenta("\t\tEVM Instructions:\n")
-                    node_pcs = contract_pcs.get(node_source_line, [])
-                    for pc in node_pcs:
-                        txt += magenta(f"\t\t\t{hex(pc)}: {contract_cfg.get_instruction_at(pc)}\n")
+
+                txt += self.build_element_node_str(
+                    modifier,
+                    evm_info["mapping", contract.name],
+                    evm_info["cfg", contract.name],
+                )
 
         self.info(txt)
         res = self.generate_output(txt)

slither/printers/summary/variable_order.py

@@ -28,10 +28,9 @@ class VariableOrder(AbstractPrinter):
         for contract in self.slither.contracts_derived:
             txt += f"\n{contract.name}:\n"
             table = MyPrettyTable(["Name", "Type", "Slot", "Offset"])
-            for variable in contract.state_variables_ordered:
-                if not variable.is_constant and not variable.is_immutable:
-                    slot, offset = contract.compilation_unit.storage_layout_of(contract, variable)
-                    table.add_row([variable.canonical_name, str(variable.type), slot, offset])
+            for variable in contract.stored_state_variables_ordered:
+                slot, offset = contract.compilation_unit.storage_layout_of(contract, variable)
+                table.add_row([variable.canonical_name, str(variable.type), slot, offset])
 
             all_tables.append((contract.name, table))
             txt += str(table) + "\n"

slither/slither.py

@@ -1,11 +1,10 @@
 import logging
-from typing import Union, List, ValuesView, Type, Dict, Optional
+from typing import Union, List, Type, Dict, Optional
 
 from crytic_compile import CryticCompile, InvalidCompilation
 
 # pylint: disable= no-name-in-module
 from slither.core.compilation_unit import SlitherCompilationUnit
-from slither.core.scope.scope import FileScope
 from slither.core.slither_core import SlitherCore
 from slither.detectors.abstract_detector import AbstractDetector, DetectorClassification
 from slither.exceptions import SlitherError
@@ -27,32 +26,71 @@ def _check_common_things(
 ) -> None:
 
     if not issubclass(cls, base_cls) or cls is base_cls:
-        raise Exception(
+        raise SlitherError(
             f"You can't register {cls!r} as a {thing_name}. You need to pass a class that inherits from {base_cls.__name__}"
         )
 
     if any(type(obj) == cls for obj in instances_list):  # pylint: disable=unidiomatic-typecheck
-        raise Exception(f"You can't register {cls!r} twice.")
+        raise SlitherError(f"You can't register {cls!r} twice.")
 
 
-def _update_file_scopes(candidates: ValuesView[FileScope]):
+def _update_file_scopes(
+    sol_parser: SlitherCompilationUnitSolc,
+):  # pylint: disable=too-many-branches
     """
-    Because solc's import allows cycle in the import
-    We iterate until we aren't adding new information to the scope
-
+    Since all definitions in a file are exported by default, including definitions from its (transitive) dependencies,
+    we can identify all top level items that could possibly be referenced within the file from its exportedSymbols.
+    It is not as straightforward for user defined types and functions as well as aliasing. See add_accessible_scopes for more details.
     """
+    candidates = sol_parser.compilation_unit.scopes.values()
     learned_something = False
+    # Because solc's import allows cycle in the import graph, iterate until we aren't adding new information to the scope.
     while True:
         for candidate in candidates:
-            learned_something |= candidate.add_accesible_scopes()
+            learned_something |= candidate.add_accessible_scopes()
         if not learned_something:
             break
         learned_something = False
 
+    for scope in candidates:
+        for refId in scope.exported_symbols:
+            if refId in sol_parser.contracts_by_id:
+                contract = sol_parser.contracts_by_id[refId]
+                scope.contracts[contract.name] = contract
+            elif refId in sol_parser.functions_by_id:
+                functions = sol_parser.functions_by_id[refId]
+                assert len(functions) == 1
+                scope.functions.add(functions[0])
+            elif refId in sol_parser.imports_by_id:
+                import_directive = sol_parser.imports_by_id[refId]
+                scope.imports.add(import_directive)
+            elif refId in sol_parser.top_level_variables_by_id:
+                top_level_variable = sol_parser.top_level_variables_by_id[refId]
+                scope.variables[top_level_variable.name] = top_level_variable
+            elif refId in sol_parser.top_level_events_by_id:
+                top_level_event = sol_parser.top_level_events_by_id[refId]
+                scope.events.add(top_level_event)
+            elif refId in sol_parser.top_level_structures_by_id:
+                top_level_struct = sol_parser.top_level_structures_by_id[refId]
+                scope.structures[top_level_struct.name] = top_level_struct
+            elif refId in sol_parser.top_level_type_aliases_by_id:
+                top_level_type_alias = sol_parser.top_level_type_aliases_by_id[refId]
+                scope.type_aliases[top_level_type_alias.name] = top_level_type_alias
+            elif refId in sol_parser.top_level_enums_by_id:
+                top_level_enum = sol_parser.top_level_enums_by_id[refId]
+                scope.enums[top_level_enum.name] = top_level_enum
+            elif refId in sol_parser.top_level_errors_by_id:
+                top_level_custom_error = sol_parser.top_level_errors_by_id[refId]
+                scope.custom_errors.add(top_level_custom_error)
+            else:
+                logger.error(
+                    f"Failed to resolved name for reference id {refId} in {scope.filename.absolute}."
+                )
+
 
 class Slither(
     SlitherCore
-):  # pylint: disable=too-many-instance-attributes,too-many-locals,too-many-statements
+):  # pylint: disable=too-many-instance-attributes,too-many-locals,too-many-statements,too-many-branches
     def __init__(self, target: Union[str, CryticCompile], **kwargs) -> None:
         """
         Args:
@@ -118,7 +156,18 @@ class Slither(
                     sol_parser.parse_top_level_items(ast, path)
                     self.add_source_code(path)
 
-                _update_file_scopes(compilation_unit_slither.scopes.values())
+                for contract in sol_parser._underlying_contract_to_parser:
+                    if contract.name.startswith("SlitherInternalTopLevelContract"):
+                        raise SlitherError(
+                            # region multi-line-string
+                            """Your codebase has a contract named 'SlitherInternalTopLevelContract'.
+        Please rename it, this name is reserved for Slither's internals"""
+                            # endregion multi-line
+                        )
+                    sol_parser._contracts_by_id[contract.id] = contract
+                    sol_parser._compilation_unit.contracts.append(contract)
+
+                _update_file_scopes(sol_parser)
 
         if kwargs.get("generate_patches", False):
             self.generate_patches = True
@@ -132,10 +181,16 @@ class Slither(
         for p in filter_paths:
             self.add_path_to_filter(p)
 
+        include_paths = kwargs.get("include_paths", [])
+        for p in include_paths:
+            self.add_path_to_include(p)
+
         self._exclude_dependencies = kwargs.get("exclude_dependencies", False)
 
         triage_mode = kwargs.get("triage_mode", False)
+        triage_database = kwargs.get("triage_database", "slither.db.json")
         self._triage_mode = triage_mode
+        self._previous_results_filename = triage_database
 
         printers_to_run = kwargs.get("printers_to_run", "")
         if printers_to_run == "echidna":

slither/slithir/convert.py

@@ -1,6 +1,6 @@
 import logging
 from pathlib import Path
-from typing import Any, List, TYPE_CHECKING, Union, Optional, Dict
+from typing import Any, List, TYPE_CHECKING, Union, Optional
 
 # pylint: disable= too-many-lines,import-outside-toplevel,too-many-branches,too-many-statements,too-many-nested-blocks
 from slither.core.declarations import (
@@ -13,7 +13,6 @@ from slither.core.declarations import (
     SolidityVariableComposed,
     Structure,
 )
-from slither.core.declarations.contract import USING_FOR_KEY, USING_FOR_ITEM
 from slither.core.declarations.custom_error import CustomError
 from slither.core.declarations.function_contract import FunctionContract
 from slither.core.declarations.function_top_level import FunctionTopLevel
@@ -84,6 +83,7 @@ from slither.slithir.variables import Constant, ReferenceVariable, TemporaryVari
 from slither.slithir.variables import TupleVariable
 from slither.utils.function import get_function_id
 from slither.utils.type import export_nested_types_from_variable
+from slither.utils.using_for import USING_FOR
 from slither.visitors.slithir.expression_to_slithir import ExpressionToSlithIR
 
 if TYPE_CHECKING:
@@ -482,7 +482,7 @@ def propagate_type_and_convert_call(result: List[Operation], node: "Node") -> Li
             call_data.remove(ins.variable)
 
         if isinstance(ins, Argument):
-            # In case of dupplicate arguments we overwrite the value
+            # In case of duplicate arguments we overwrite the value
             # This can happen because of addr.call.value(1).value(2)
             if ins.get_type() in [ArgumentType.GAS]:
                 calls_gas[ins.call_id] = ins.argument
@@ -594,11 +594,13 @@ def _convert_type_contract(ir: Member) -> Assignment:
 def propagate_types(ir: Operation, node: "Node"):  # pylint: disable=too-many-locals
     # propagate the type
     node_function = node.function
-    using_for: Dict[USING_FOR_KEY, USING_FOR_ITEM] = (
-        node_function.contract.using_for_complete
-        if isinstance(node_function, FunctionContract)
-        else {}
-    )
+
+    using_for: USING_FOR = {}
+    if isinstance(node_function, FunctionContract):
+        using_for = node_function.contract.using_for_complete
+    elif isinstance(node_function, FunctionTopLevel):
+        using_for = node_function.using_for_complete
+
     if isinstance(ir, OperationWithLValue) and ir.lvalue:
         # Force assignment in case of missing previous correct type
         if not ir.lvalue.type:
@@ -630,6 +632,17 @@ def propagate_types(ir: Operation, node: "Node"):  # pylint: disable=too-many-lo
                     if new_ir:
                         return new_ir
 
+                # convert library function when used with "this"
+                if (
+                    isinstance(t, ElementaryType)
+                    and t.name == "address"
+                    and ir.destination.name == "this"
+                    and UserDefinedType(node_function.contract) in using_for
+                ):
+                    new_ir = convert_to_library_or_top_level(ir, node, using_for)
+                    if new_ir:
+                        return new_ir
+
                 if isinstance(t, UserDefinedType):
                     # UserdefinedType
                     t_type = t.type
@@ -860,9 +873,7 @@ def propagate_types(ir: Operation, node: "Node"):  # pylint: disable=too-many-lo
             elif isinstance(ir, NewArray):
                 ir.lvalue.set_type(ir.array_type)
             elif isinstance(ir, NewContract):
-                contract = node.file_scope.get_contract_from_name(ir.contract_name)
-                assert contract
-                ir.lvalue.set_type(UserDefinedType(contract))
+                ir.lvalue.set_type(ir.contract_name)
             elif isinstance(ir, NewElementaryType):
                 ir.lvalue.set_type(ir.type)
             elif isinstance(ir, NewStructure):
@@ -1153,7 +1164,7 @@ def extract_tmp_call(ins: TmpCall, contract: Optional[Contract]) -> Union[Call,
         return n
 
     if isinstance(ins.ori, TmpNewContract):
-        op = NewContract(Constant(ins.ori.contract_name), ins.lvalue)
+        op = NewContract(ins.ori.contract_name, ins.lvalue)
         op.set_expression(ins.expression)
         op.call_id = ins.call_id
         if ins.call_value:
@@ -1198,7 +1209,7 @@ def extract_tmp_call(ins: TmpCall, contract: Optional[Contract]) -> Union[Call,
         internalcall.set_expression(ins.expression)
         return internalcall
 
-    raise Exception(f"Not extracted {type(ins.called)} {ins}")
+    raise SlithIRError(f"Not extracted {type(ins.called)} {ins}")
 
 
 # endregion
@@ -1491,7 +1502,6 @@ def convert_to_pop(ir: HighLevelCall, node: "Node") -> List[Operation]:
 
 
 def look_for_library_or_top_level(
-    contract: Contract,
     ir: HighLevelCall,
     using_for,
     t: Union[
@@ -1522,10 +1532,12 @@ def look_for_library_or_top_level(
                     internalcall.lvalue = None
                 return internalcall
 
+        lib_contract = None
         if isinstance(destination, FunctionContract) and destination.contract.is_library:
             lib_contract = destination.contract
-        else:
-            lib_contract = contract.file_scope.get_contract_from_name(str(destination))
+        elif isinstance(destination, UserDefinedType) and isinstance(destination.type, Contract):
+            lib_contract = destination.type
+
         if lib_contract:
             lib_call = LibraryCall(
                 lib_contract,
@@ -1549,18 +1561,26 @@ def look_for_library_or_top_level(
 def convert_to_library_or_top_level(
     ir: HighLevelCall, node: "Node", using_for
 ) -> Optional[Union[LibraryCall, InternalCall,]]:
-    # We use contract_declarer, because Solidity resolve the library
-    # before resolving the inheritance.
-    # Though we could use .contract as libraries cannot be shadowed
-    contract = node.function.contract_declarer
     t = ir.destination.type
     if t in using_for:
-        new_ir = look_for_library_or_top_level(contract, ir, using_for, t)
+        new_ir = look_for_library_or_top_level(ir, using_for, t)
         if new_ir:
             return new_ir
 
     if "*" in using_for:
-        new_ir = look_for_library_or_top_level(contract, ir, using_for, "*")
+        new_ir = look_for_library_or_top_level(ir, using_for, "*")
+        if new_ir:
+            return new_ir
+
+    if (
+        isinstance(t, ElementaryType)
+        and t.name == "address"
+        and ir.destination.name == "this"
+        and UserDefinedType(node.function.contract) in using_for
+    ):
+        new_ir = look_for_library_or_top_level(
+            ir, using_for, UserDefinedType(node.function.contract)
+        )
         if new_ir:
             return new_ir
 
@@ -1696,6 +1716,7 @@ def convert_type_of_high_and_internal_level_call(
     Returns:
         Potential new IR
     """
+
     func = None
     if isinstance(ir, InternalCall):
         candidates: List[Function]
@@ -1713,7 +1734,10 @@ def convert_type_of_high_and_internal_level_call(
             ]
 
             for import_statement in contract.file_scope.imports:
-                if import_statement.alias and import_statement.alias == ir.contract_name:
+                if (
+                    import_statement.alias is not None
+                    and import_statement.alias == ir.contract_name
+                ):
                     imported_scope = contract.compilation_unit.get_scope(import_statement.filename)
                     candidates += [
                         f
@@ -1744,7 +1768,7 @@ def convert_type_of_high_and_internal_level_call(
         if func is None and candidates:
             func = _find_function_from_parameter(ir.arguments, candidates, False)
 
-    # lowlelvel lookup needs to be done at last step
+    # low level lookup needs to be done as last step
     if not func:
         if can_be_low_level(ir):
             return convert_to_low_level(ir)
@@ -1899,35 +1923,21 @@ def convert_constant_types(irs: List[Operation]) -> None:
     while was_changed:
         was_changed = False
         for ir in irs:
-            if isinstance(ir, Assignment):
-                if isinstance(ir.lvalue.type, ElementaryType):
-                    if ir.lvalue.type.type in ElementaryTypeInt:
-                        if isinstance(ir.rvalue, Function):
-                            continue
-                        if isinstance(ir.rvalue, TupleVariable):
-                            # TODO: fix missing Unpack conversion
-                            continue
-                        if isinstance(ir.rvalue.type, TypeAlias):
-                            ir.rvalue.set_type(ElementaryType(ir.lvalue.type.name))
-                            was_changed = True
-                        elif ir.rvalue.type.type not in ElementaryTypeInt:
-                            ir.rvalue.set_type(ElementaryType(ir.lvalue.type.type))
+            if isinstance(ir, (Assignment, Binary)):
+                if (
+                    isinstance(ir.lvalue.type, ElementaryType)
+                    and ir.lvalue.type.type in ElementaryTypeInt
+                ):
+                    for r in ir.read:
+                        if isinstance(r, Constant) and r.type.type not in ElementaryTypeInt:
+                            r.set_type(ElementaryType(ir.lvalue.type.type))
                             was_changed = True
-            if isinstance(ir, Binary):
-                if isinstance(ir.lvalue.type, ElementaryType):
-                    if ir.lvalue.type.type in ElementaryTypeInt:
-                        for r in ir.read:
-                            if r.type.type not in ElementaryTypeInt:
-                                r.set_type(ElementaryType(ir.lvalue.type.type))
-                                was_changed = True
+
             if isinstance(ir, (HighLevelCall, InternalCall)):
                 func = ir.function
                 if isinstance(func, StateVariable):
                     types = export_nested_types_from_variable(func)
                 else:
-                    if func is None:
-                        # TODO: add  POP instruction
-                        break
                     types = [p.type for p in func.parameters]
                 assert len(types) == len(ir.arguments)
                 for idx, arg in enumerate(ir.arguments):
@@ -1937,6 +1947,7 @@ def convert_constant_types(irs: List[Operation]) -> None:
                             if arg.type.type not in ElementaryTypeInt:
                                 arg.set_type(ElementaryType(t.type))
                                 was_changed = True
+
             if isinstance(ir, NewStructure):
                 st = ir.structure
                 for idx, arg in enumerate(ir.arguments):
@@ -1946,11 +1957,15 @@ def convert_constant_types(irs: List[Operation]) -> None:
                             if arg.type.type not in ElementaryTypeInt:
                                 arg.set_type(ElementaryType(e.type.type))
                                 was_changed = True
+
+            def is_elementary_array(t):
+                return isinstance(t, ArrayType) and isinstance(t.type, ElementaryType)
+
             if isinstance(ir, InitArray):
-                if isinstance(ir.lvalue.type, ArrayType):
-                    if isinstance(ir.lvalue.type.type, ElementaryType):
-                        if ir.lvalue.type.type.type in ElementaryTypeInt:
-                            for r in ir.read:
+                if is_elementary_array(ir.lvalue.type):
+                    if ir.lvalue.type.type.type in ElementaryTypeInt:
+                        for r in ir.read:
+                            if isinstance(r, Constant) and is_elementary_array(r.type):
                                 if r.type.type.type not in ElementaryTypeInt:
                                     r.set_type(ElementaryType(ir.lvalue.type.type.type))
                                     was_changed = True
@@ -1991,6 +2006,9 @@ def _find_source_mapping_references(irs: List[Operation]) -> None:
         if isinstance(ir, NewContract):
             ir.contract_created.references.append(ir.expression.source_mapping)
 
+        if isinstance(ir, HighLevelCall):
+            ir.function.references.append(ir.expression.source_mapping)
+
 
 # endregion
 ###################################################################################

slither/slithir/operations/call.py

@@ -34,7 +34,6 @@ class Call(Operation):
     def arguments(self, v: List[Variable]) -> None:
         self._arguments = v
 
-    # pylint: disable=no-self-use
     def can_reenter(self, _callstack: Optional[List[Union[Function, Variable]]] = None) -> bool:
         """
         Must be called after slithIR analysis pass
@@ -42,7 +41,7 @@ class Call(Operation):
         """
         return False
 
-    def can_send_eth(self) -> bool:  # pylint: disable=no-self-use
+    def can_send_eth(self) -> bool:
         """
         Must be called after slithIR analysis pass
         :return: bool

slither/slithir/operations/high_level_call.py

@@ -54,7 +54,6 @@ class HighLevelCall(Call, OperationWithLValue):
 
     # Development function, to be removed once the code is stable
     # It is overridden by LibraryCall
-    # pylint: disable=no-self-use
     def _check_destination(self, destination: Union[Variable, SolidityVariable, Contract]) -> None:
         assert isinstance(destination, (Variable, SolidityVariable))
 

slither/slithir/operations/init_array.py

@@ -1,14 +1,13 @@
 from typing import List, Union
 from slither.slithir.operations.lvalue import OperationWithLValue
-from slither.slithir.utils.utils import is_valid_rvalue
-from slither.slithir.variables.constant import Constant
+from slither.slithir.utils.utils import is_valid_rvalue, RVALUE
 from slither.slithir.variables.temporary import TemporaryVariable
 from slither.slithir.variables.temporary_ssa import TemporaryVariableSSA
 
 
 class InitArray(OperationWithLValue):
     def __init__(
-        self, init_values: List[Constant], lvalue: Union[TemporaryVariableSSA, TemporaryVariable]
+        self, init_values: List[RVALUE], lvalue: Union[TemporaryVariableSSA, TemporaryVariable]
     ) -> None:
         # init_values can be an array of n dimension
         # reduce was removed in py3
@@ -30,11 +29,11 @@ class InitArray(OperationWithLValue):
         self._lvalue = lvalue
 
     @property
-    def read(self) -> List[Constant]:
+    def read(self) -> List[RVALUE]:
         return self._unroll(self.init_values)
 
     @property
-    def init_values(self) -> List[Constant]:
+    def init_values(self) -> List[RVALUE]:
         return list(self._init_values)
 
     def __str__(self):

slither/slithir/operations/new_array.py

@@ -3,9 +3,9 @@ from typing import List, Union, TYPE_CHECKING
 from slither.core.solidity_types.array_type import ArrayType
 from slither.slithir.operations.call import Call
 from slither.slithir.operations.lvalue import OperationWithLValue
+from slither.slithir.utils.utils import RVALUE
 
 if TYPE_CHECKING:
-    from slither.slithir.variables.constant import Constant
     from slither.slithir.variables.temporary import TemporaryVariable
     from slither.slithir.variables.temporary_ssa import TemporaryVariableSSA
 
@@ -27,7 +27,7 @@ class NewArray(Call, OperationWithLValue):
         return self._array_type
 
     @property
-    def read(self) -> List["Constant"]:
+    def read(self) -> List[RVALUE]:
         return self._unroll(self.arguments)
 
     def __str__(self):

slither/slithir/operations/new_contract.py

@@ -3,9 +3,9 @@ from typing import Optional, Any, List, Union
 from slither.core.declarations import Function
 from slither.core.declarations.contract import Contract
 from slither.core.variables import Variable
+from slither.core.solidity_types import UserDefinedType
 from slither.slithir.operations import Call, OperationWithLValue
 from slither.slithir.utils.utils import is_valid_lvalue
-from slither.slithir.variables.constant import Constant
 from slither.slithir.variables.temporary import TemporaryVariable
 from slither.slithir.variables.temporary_ssa import TemporaryVariableSSA
 
@@ -13,7 +13,7 @@ from slither.slithir.variables.temporary_ssa import TemporaryVariableSSA
 class NewContract(Call, OperationWithLValue):  # pylint: disable=too-many-instance-attributes
     def __init__(
         self,
-        contract_name: Constant,
+        contract_name: UserDefinedType,
         lvalue: Union[TemporaryVariableSSA, TemporaryVariable],
         names: Optional[List[str]] = None,
     ) -> None:
@@ -23,7 +23,9 @@ class NewContract(Call, OperationWithLValue):  # pylint: disable=too-many-instan
             For calls of the form f({argName1 : arg1, ...}), the names of parameters listed in call order.
             Otherwise, None.
         """
-        assert isinstance(contract_name, Constant)
+        assert isinstance(
+            contract_name.type, Contract
+        ), f"contract_name is {contract_name} of type {type(contract_name)}"
         assert is_valid_lvalue(lvalue)
         super().__init__(names=names)
         self._contract_name = contract_name
@@ -58,7 +60,7 @@ class NewContract(Call, OperationWithLValue):  # pylint: disable=too-many-instan
         self._call_salt = s
 
     @property
-    def contract_name(self) -> Constant:
+    def contract_name(self) -> UserDefinedType:
         return self._contract_name
 
     @property
@@ -69,10 +71,7 @@ class NewContract(Call, OperationWithLValue):  # pylint: disable=too-many-instan
 
     @property
     def contract_created(self) -> Contract:
-        contract_name = self.contract_name
-        contract_instance = self.node.file_scope.get_contract_from_name(contract_name)
-        assert contract_instance
-        return contract_instance
+        return self.contract_name.type
 
     ###################################################################################
     ###################################################################################

slither/slithir/utils/ssa.py

@@ -90,13 +90,13 @@ def transform_slithir_vars_to_ssa(
 
     tmp_variables = [v for v in variables if isinstance(v, TemporaryVariable)]
     for idx, _ in enumerate(tmp_variables):
-        tmp_variables[idx].index = idx
+        tmp_variables[idx].index = idx  # pylint: disable=unnecessary-list-index-lookup
     ref_variables = [v for v in variables if isinstance(v, ReferenceVariable)]
     for idx, _ in enumerate(ref_variables):
-        ref_variables[idx].index = idx
+        ref_variables[idx].index = idx  # pylint: disable=unnecessary-list-index-lookup
     tuple_variables = [v for v in variables if isinstance(v, TupleVariable)]
     for idx, _ in enumerate(tuple_variables):
-        tuple_variables[idx].index = idx
+        tuple_variables[idx].index = idx  # pylint: disable=unnecessary-list-index-lookup
 
 
 ###################################################################################

slither/solc_parsing/declarations/contract.py

@@ -1,28 +1,29 @@
 import logging
 import re
-from typing import Any, List, Dict, Callable, TYPE_CHECKING, Union, Set, Sequence
+from typing import Any, List, Dict, Callable, TYPE_CHECKING, Union, Set, Sequence, Tuple
 
 from slither.core.declarations import (
     Modifier,
-    Event,
+    EventContract,
     EnumContract,
     StructureContract,
     Function,
 )
-from slither.core.declarations.contract import Contract, USING_FOR_KEY
+from slither.core.declarations.contract import Contract
 from slither.core.declarations.custom_error_contract import CustomErrorContract
 from slither.core.declarations.function_contract import FunctionContract
 from slither.core.solidity_types import ElementaryType, TypeAliasContract
 from slither.core.variables.state_variable import StateVariable
 from slither.solc_parsing.declarations.caller_context import CallerContextExpression
 from slither.solc_parsing.declarations.custom_error import CustomErrorSolc
-from slither.solc_parsing.declarations.event import EventSolc
+from slither.solc_parsing.declarations.event_contract import EventContractSolc
 from slither.solc_parsing.declarations.function import FunctionSolc
 from slither.solc_parsing.declarations.modifier import ModifierSolc
 from slither.solc_parsing.declarations.structure_contract import StructureContractSolc
 from slither.solc_parsing.exceptions import ParsingError, VariableNotFound
 from slither.solc_parsing.solidity_types.type_parsing import parse_type
 from slither.solc_parsing.variables.state_variable import StateVariableSolc
+from slither.utils.using_for import USING_FOR_KEY
 
 LOGGER = logging.getLogger("ContractSolcParsing")
 
@@ -64,7 +65,8 @@ class ContractSolc(CallerContextExpression):
         # use to remap inheritance id
         self._remapping: Dict[str, str] = {}
 
-        self.baseContracts: List[str] = []
+        # (referencedDeclaration, offset)
+        self.baseContracts: List[Tuple[int, str]] = []
         self.baseConstructorContractsCalled: List[str] = []
         self._linearized_base_contracts: List[int]
 
@@ -174,6 +176,9 @@ class ContractSolc(CallerContextExpression):
         self._contract.is_fully_implemented = attributes["fullyImplemented"]
         self._linearized_base_contracts = attributes["linearizedBaseContracts"]
 
+        if "abstract" in attributes:
+            self._contract.is_abstract = attributes["abstract"]
+
         # Parse base contract information
         self._parse_base_contract_info()
 
@@ -201,7 +206,9 @@ class ContractSolc(CallerContextExpression):
 
                     # Obtain our contract reference and add it to our base contract list
                     referencedDeclaration = base_contract["baseName"]["referencedDeclaration"]
-                    self.baseContracts.append(referencedDeclaration)
+                    self.baseContracts.append(
+                        (referencedDeclaration, base_contract["baseName"]["src"])
+                    )
 
                     # If we have defined arguments in our arguments object, this is a constructor invocation.
                     # (note: 'arguments' can be [], which is not the same as None. [] implies a constructor was
@@ -233,7 +240,10 @@ class ContractSolc(CallerContextExpression):
                     referencedDeclaration = base_contract_items[0]["attributes"][
                         "referencedDeclaration"
                     ]
-                    self.baseContracts.append(referencedDeclaration)
+
+                    self.baseContracts.append(
+                        (referencedDeclaration, base_contract_items[0]["src"])
+                    )
 
                     # If we have an 'attributes'->'arguments' which is None, this is not a constructor call.
                     if (
@@ -575,13 +585,15 @@ class ContractSolc(CallerContextExpression):
                     element.is_shadowed = True
                     accessible_elements[element.full_name].shadows = True
         except (VariableNotFound, KeyError) as e:
-            self.log_incorrect_parsing(f"Missing params {e}")
+            self.log_incorrect_parsing(
+                f"Missing params {e} {self._contract.source_mapping.to_detailed_str()}"
+            )
         return all_elements
 
     def analyze_constant_state_variables(self) -> None:
         for var_parser in self._variables_parser:
             if var_parser.underlying_variable.is_constant:
-                # cant parse constant expression based on function calls
+                # can't parse constant expression based on function calls
                 try:
                     var_parser.analyze(self)
                 except (VariableNotFound, KeyError) as e:
@@ -727,7 +739,7 @@ class ContractSolc(CallerContextExpression):
         new_enum.set_offset(enum["src"], self._contract.compilation_unit)
         self._contract.enums_as_dict[canonicalName] = new_enum
 
-    def _analyze_struct(self, struct: StructureContractSolc) -> None:  # pylint: disable=no-self-use
+    def _analyze_struct(self, struct: StructureContractSolc) -> None:
         struct.analyze()
 
     def analyze_structs(self) -> None:
@@ -747,12 +759,12 @@ class ContractSolc(CallerContextExpression):
                 self._contract.events_as_dict.update(father.events_as_dict)
 
             for event_to_parse in self._eventsNotParsed:
-                event = Event()
+                event = EventContract()
                 event.set_contract(self._contract)
                 event.set_offset(event_to_parse["src"], self._contract.compilation_unit)
 
-                event_parser = EventSolc(event, event_to_parse, self)  # type: ignore
-                event_parser.analyze(self)  # type: ignore
+                event_parser = EventContractSolc(event, event_to_parse, self)  # type: ignore
+                event_parser.analyze()  # type: ignore
                 self._contract.events_as_dict[event.full_name] = event
         except (VariableNotFound, KeyError) as e:
             self.log_incorrect_parsing(f"Missing event {e}")

slither/solc_parsing/declarations/event_contract.py

@@ -1,26 +1,27 @@
 """
-    Event module
+    EventContract module
 """
 from typing import TYPE_CHECKING, Dict
 
 from slither.core.variables.event_variable import EventVariable
 from slither.solc_parsing.variables.event_variable import EventVariableSolc
-from slither.core.declarations.event import Event
+from slither.core.declarations.event_contract import EventContract
 
 if TYPE_CHECKING:
     from slither.solc_parsing.declarations.contract import ContractSolc
 
 
-class EventSolc:
+class EventContractSolc:
     """
-    Event class
+    EventContract class
     """
 
-    def __init__(self, event: Event, event_data: Dict, contract_parser: "ContractSolc") -> None:
+    def __init__(
+        self, event: EventContract, event_data: Dict, contract_parser: "ContractSolc"
+    ) -> None:
 
         self._event = event
-        event.set_contract(contract_parser.underlying_contract)
-        self._parser_contract = contract_parser
+        self._contract_parser = contract_parser
 
         if self.is_compact_ast:
             self._event.name = event_data["name"]
@@ -41,18 +42,16 @@ class EventSolc:
 
     @property
     def is_compact_ast(self) -> bool:
-        return self._parser_contract.is_compact_ast
+        return self._contract_parser.is_compact_ast
 
-    def analyze(self, contract: "ContractSolc") -> None:
+    def analyze(self) -> None:
         for elem_to_parse in self._elemsNotParsed:
             elem = EventVariable()
             # Todo: check if the source offset is always here
             if "src" in elem_to_parse:
-                elem.set_offset(
-                    elem_to_parse["src"], self._parser_contract.underlying_contract.compilation_unit
-                )
+                elem.set_offset(elem_to_parse["src"], self._contract_parser.compilation_unit)
             elem_parser = EventVariableSolc(elem, elem_to_parse)
-            elem_parser.analyze(contract)
+            elem_parser.analyze(self._contract_parser)
 
             self._event.elems.append(elem)
 

slither/solc_parsing/declarations/event_top_level.py

@@ -0,0 +1,75 @@
+"""
+    EventTopLevel module
+"""
+from typing import TYPE_CHECKING, Dict
+
+from slither.core.declarations.event_top_level import EventTopLevel
+from slither.core.variables.event_variable import EventVariable
+from slither.core.compilation_unit import SlitherCompilationUnit
+from slither.solc_parsing.variables.event_variable import EventVariableSolc
+from slither.solc_parsing.declarations.caller_context import CallerContextExpression
+
+if TYPE_CHECKING:
+    from slither.solc_parsing.slither_compilation_unit_solc import SlitherCompilationUnitSolc
+
+
+class EventTopLevelSolc(CallerContextExpression):
+    """
+    EventTopLevel class
+    """
+
+    def __init__(
+        self, event: EventTopLevel, event_data: Dict, slither_parser: "SlitherCompilationUnitSolc"
+    ) -> None:
+
+        self._event = event
+        self._slither_parser = slither_parser
+
+        if self.is_compact_ast:
+            self._event.name = event_data["name"]
+            elems = event_data["parameters"]
+            assert elems["nodeType"] == "ParameterList"
+            self._elemsNotParsed = elems["parameters"]
+        else:
+            self._event.name = event_data["attributes"]["name"]
+            for elem in event_data["children"]:
+                # From Solidity 0.6.3 to 0.6.10 (included)
+                # Comment above a event might be added in the children
+                # of an event for the legacy ast
+                if elem["name"] == "ParameterList":
+                    if "children" in elem:
+                        self._elemsNotParsed = elem["children"]
+                    else:
+                        self._elemsNotParsed = []
+
+    def analyze(self) -> None:
+        for elem_to_parse in self._elemsNotParsed:
+            elem = EventVariable()
+            # Todo: check if the source offset is always here
+            if "src" in elem_to_parse:
+                elem.set_offset(elem_to_parse["src"], self._slither_parser.compilation_unit)
+            elem_parser = EventVariableSolc(elem, elem_to_parse)
+            elem_parser.analyze(self)
+
+            self._event.elems.append(elem)
+
+        self._elemsNotParsed = []
+
+    @property
+    def is_compact_ast(self) -> bool:
+        return self._slither_parser.is_compact_ast
+
+    @property
+    def compilation_unit(self) -> SlitherCompilationUnit:
+        return self._slither_parser.compilation_unit
+
+    def get_key(self) -> str:
+        return self._slither_parser.get_key()
+
+    @property
+    def slither_parser(self) -> "SlitherCompilationUnitSolc":
+        return self._slither_parser
+
+    @property
+    def underlying_event(self) -> EventTopLevel:
+        return self._event

slither/solc_parsing/declarations/function.py

@@ -63,11 +63,14 @@ class FunctionSolc(CallerContextExpression):
         # Only present if compact AST
         if self.is_compact_ast:
             self._function.name = function_data["name"]
-            if "id" in function_data:
-                self._function.id = function_data["id"]
         else:
             self._function.name = function_data["attributes"][self.get_key()]
+
+        if "id" in function_data:
+            self._function.id = function_data["id"]
+
         self._functionNotParsed = function_data
+        self._returnsNotParsed: List[dict] = []
         self._params_was_analyzed = False
         self._content_was_analyzed = False
 
@@ -207,8 +210,6 @@ class FunctionSolc(CallerContextExpression):
         else:
             attributes = self._functionNotParsed["attributes"]
 
-        if "payable" in attributes:
-            self._function.payable = attributes["payable"]
         if "stateMutability" in attributes:
             if attributes["stateMutability"] == "payable":
                 self._function.payable = True
@@ -242,6 +243,34 @@ class FunctionSolc(CallerContextExpression):
         if "payable" in attributes:
             self._function.payable = attributes["payable"]
 
+        if "baseFunctions" in attributes:
+            overrides_ids = attributes["baseFunctions"]
+            if len(overrides_ids) > 0:
+                for f_id in overrides_ids:
+                    funcs = self.slither_parser.functions_by_id[f_id]
+                    for f in funcs:
+                        # Do not consider leaf contracts as overrides.
+                        # B is A { function a() override {} } and C is A { function a() override {} } override A.a(), not each other.
+                        if (
+                            f.contract == self._function.contract
+                            or f.contract in self._function.contract.inheritance
+                        ):
+                            self._function.overrides.append(f)
+                            f.overridden_by.append(self._function)
+
+        # Attaches reference to override specifier e.g. X is referenced by `function a() override(X)`
+        if "overrides" in attributes and isinstance(attributes["overrides"], dict):
+            for override in attributes["overrides"].get("overrides", []):
+                refId = override["referencedDeclaration"]
+                overridden_contract = self.slither_parser.contracts_by_id.get(refId, None)
+                if overridden_contract:
+                    overridden_contract.add_reference_from_raw_source(
+                        override["src"], self.compilation_unit
+                    )
+
+        if "virtual" in attributes:
+            self._function.is_virtual = attributes["virtual"]
+
     def analyze_params(self) -> None:
         # Can be re-analyzed due to inheritance
         if self._params_was_analyzed:
@@ -280,6 +309,7 @@ class FunctionSolc(CallerContextExpression):
 
         if self.is_compact_ast:
             body = self._functionNotParsed.get("body", None)
+            return_params = self._functionNotParsed.get("returnParameters", None)
 
             if body and body[self.get_key()] == "Block":
                 self._function.is_implemented = True
@@ -290,6 +320,7 @@ class FunctionSolc(CallerContextExpression):
 
         else:
             children = self._functionNotParsed[self.get_children("children")]
+            return_params = children[1]
             self._function.is_implemented = False
             for child in children[2:]:
                 if child[self.get_key()] == "Block":
@@ -315,6 +346,9 @@ class FunctionSolc(CallerContextExpression):
 
         self._remove_alone_endif()
 
+        if return_params:
+            self._fix_implicit_return(return_params)
+
         if self._function.entry_point:
             self._update_reachability(self._function.entry_point)
 
@@ -428,7 +462,7 @@ class FunctionSolc(CallerContextExpression):
 
         return node_endWhile
 
-    def _parse_for_compact_ast(  # pylint: disable=no-self-use
+    def _parse_for_compact_ast(
         self, statement: Dict
     ) -> Tuple[Optional[Dict], Optional[Dict], Optional[Dict], Dict]:
         body = statement["body"]
@@ -637,7 +671,6 @@ class FunctionSolc(CallerContextExpression):
         link_underlying_nodes(node_condition, node_endDoWhile)
         return node_endDoWhile
 
-    # pylint: disable=no-self-use
     def _construct_try_expression(self, externalCall: Dict, parameters_list: Dict) -> Dict:
         # if the parameters are more than 1 we make the leftHandSide of the Assignment node
         # a TupleExpression otherwise an Identifier
@@ -818,19 +851,26 @@ class FunctionSolc(CallerContextExpression):
                             new_node = self._parse_variable_definition_init_tuple(
                                 new_statement, i, new_node, scope
                             )
+                        else:
+                            variables.append(None)
                         i = i + 1
 
                     var_identifiers = []
                     # craft of the expression doing the assignement
                     for v in variables:
-                        identifier = {
-                            "nodeType": "Identifier",
-                            "src": v["src"],
-                            "name": v["name"],
-                            "referencedDeclaration": v["id"],
-                            "typeDescriptions": {"typeString": v["typeDescriptions"]["typeString"]},
-                        }
-                        var_identifiers.append(identifier)
+                        if v is not None:
+                            identifier = {
+                                "nodeType": "Identifier",
+                                "src": v["src"],
+                                "name": v["name"],
+                                "referencedDeclaration": v["id"],
+                                "typeDescriptions": {
+                                    "typeString": v["typeDescriptions"]["typeString"]
+                                },
+                            }
+                            var_identifiers.append(identifier)
+                        else:
+                            var_identifiers.append(None)
 
                     tuple_expression = {
                         "nodeType": "TupleExpression",
@@ -996,7 +1036,9 @@ class FunctionSolc(CallerContextExpression):
                 if "operations" in statement:
                     asm_node.underlying_node.add_inline_asm(statement["operations"])
                 link_underlying_nodes(node, asm_node)
-                node = asm_node
+                end_assembly = self._new_node(NodeType.ENDASSEMBLY, statement["src"], scope)
+                link_underlying_nodes(asm_node, end_assembly)
+                node = end_assembly
         elif name == "DoWhileStatement":
             node = self._parse_dowhile(statement, node, scope)
         # For Continue / Break / Return / Throw
@@ -1106,11 +1148,13 @@ class FunctionSolc(CallerContextExpression):
         return node
 
     def _update_reachability(self, node: Node) -> None:
-        if node.is_reachable:
-            return
-        node.set_is_reachable(True)
-        for son in node.sons:
-            self._update_reachability(son)
+        worklist = [node]
+        while worklist:
+            current = worklist.pop()
+            # fix point
+            if not current.is_reachable:
+                current.set_is_reachable(True)
+                worklist.extend(current.sons)
 
     def _parse_cfg(self, cfg: Dict) -> None:
 
@@ -1161,16 +1205,38 @@ class FunctionSolc(CallerContextExpression):
 
         return None
 
-    def _find_start_loop(self, node: Node, visited: List[Node]) -> Optional[Node]:
+    def _find_if_loop(self, node: Node, visited: List[Node], skip_if_loop: int) -> Optional[Node]:
         if node in visited:
             return None
 
+        # If skip_if_loop is not 0 it means we are in a nested situation
+        # and we have to skip the closer n loop headers.
+        # If in the fathers there is an EXPRESSION node it's a for loop
+        # and it's the index increment expression
+        if node.type == NodeType.IFLOOP:
+            if skip_if_loop == 0:
+                for father in node.fathers:
+                    if father.type == NodeType.EXPRESSION:
+                        return father
+                return node
+
+        # skip_if_loop works as explained above.
+        # This handle when a for loop doesn't have a condition
+        # e.g. for (;;) {}
+        # and decrement skip_if_loop since we are out of the nested loop
         if node.type == NodeType.STARTLOOP:
-            return node
+            if skip_if_loop == 0:
+                return node
+            skip_if_loop -= 1
+
+        # If we find an ENDLOOP means we are in a nested loop
+        # we increment skip_if_loop counter
+        if node.type == NodeType.ENDLOOP:
+            skip_if_loop += 1
 
         visited = visited + [node]
         for father in node.fathers:
-            ret = self._find_start_loop(father, visited)
+            ret = self._find_if_loop(father, visited, skip_if_loop)
             if ret:
                 return ret
 
@@ -1193,15 +1259,22 @@ class FunctionSolc(CallerContextExpression):
         end_node.add_father(node)
 
     def _fix_continue_node(self, node: Node) -> None:
-        start_node = self._find_start_loop(node, [])
+        if_loop_node = self._find_if_loop(node, [], 0)
 
-        if not start_node:
+        if not if_loop_node:
             raise ParsingError(f"Continue in no-loop context {node.node_id}")
 
         for son in node.sons:
             son.remove_father(node)
-        node.set_sons([start_node])
-        start_node.add_father(node)
+        node.set_sons([if_loop_node])
+        if_loop_node.add_father(node)
+
+    # endregion
+    ###################################################################################
+    ###################################################################################
+    # region Try-Catch
+    ###################################################################################
+    ###################################################################################
 
     def _fix_try(self, node: Node) -> None:
         end_node = next((son for son in node.sons if son.type != NodeType.CATCH), None)
@@ -1219,6 +1292,13 @@ class FunctionSolc(CallerContextExpression):
                     visited.add(son)
                     self._fix_catch(son, end_node, visited)
 
+    # endregion
+    ###################################################################################
+    ###################################################################################
+    # region Params, Returns, Modifiers
+    ###################################################################################
+    ###################################################################################
+
     def _add_param(self, param: Dict, initialized: bool = False) -> LocalVariableSolc:
 
         local_var = LocalVariable()
@@ -1272,11 +1352,11 @@ class FunctionSolc(CallerContextExpression):
         self._function.returns_src().set_offset(returns["src"], self._function.compilation_unit)
 
         if self.is_compact_ast:
-            returns = returns["parameters"]
+            self._returnsNotParsed = returns["parameters"]
         else:
-            returns = returns[self.get_children("children")]
+            self._returnsNotParsed = returns[self.get_children("children")]
 
-        for ret in returns:
+        for ret in self._returnsNotParsed:
             assert ret[self.get_key()] == "VariableDeclaration"
             local_var = self._add_param(ret)
             self._function.add_return(local_var.underlying_variable)
@@ -1330,6 +1410,138 @@ class FunctionSolc(CallerContextExpression):
                     )
                 )
 
+    def _fix_implicit_return(self, return_params: Dict) -> None:
+        """
+        Creates an artificial return node iff a function has a named return variable declared in its signature.
+        Finds all leaf nodes in the CFG which are not return nodes, and links them to the artificial return node.
+        """
+        does_not_have_return_params = len(self.underlying_function.returns) == 0
+        does_not_have_named_returns = all(
+            ret.name == "" for ret in self.underlying_function.returns
+        )
+        not_implemented = not self._function.is_implemented
+
+        if does_not_have_return_params or does_not_have_named_returns or not_implemented:
+            return
+
+        return_node = self._new_node(
+            NodeType.RETURN, return_params["src"], self.underlying_function
+        )
+        for node, node_solc in self._node_to_nodesolc.items():
+            if len(node.sons) == 0 and node.type not in [NodeType.RETURN, NodeType.THROW]:
+                link_underlying_nodes(node_solc, return_node)
+
+        for _, yul_block in self._node_to_yulobject.items():
+            for yul_node in yul_block.nodes:
+                node = yul_node.underlying_node
+                if len(node.sons) == 0 and node.type not in [NodeType.RETURN, NodeType.THROW]:
+                    link_underlying_nodes(yul_node, return_node)
+
+        if self.is_compact_ast:
+            self._add_return_exp_compact(return_node, return_params)
+        else:
+            self._add_return_exp_legacy(return_node, return_params)
+
+        return_node.analyze_expressions(self)
+
+    def _add_return_exp_compact(self, return_node: NodeSolc, return_params: Dict) -> None:
+        if len(self.underlying_function.returns) == 1:
+            return_arg = self.underlying_function.returns[0]
+            if return_arg.name != "":
+                (refId, refSrc, refType) = next(
+                    (ret["id"], ret["src"], ret["typeDescriptions"])
+                    for ret in self._returnsNotParsed
+                    if ret["name"] == return_arg.name
+                )
+                return_node.add_unparsed_expression(
+                    {
+                        "name": return_arg.name,
+                        "nodeType": "Identifier",
+                        "overloadedDeclarations": [],
+                        "referencedDeclaration": refId,
+                        "src": refSrc,
+                        "typeDescriptions": refType,
+                    }
+                )
+        else:
+            expression = {
+                "components": [],
+                "isConstant": False,
+                "isInlineArray": False,
+                "isLValue": False,
+                "isPure": False,
+                "lValueRequested": False,
+                "nodeType": "TupleExpression",
+                "src": return_params["src"],
+                "typeDescriptions": {},
+            }
+            type_ids = []
+            type_strs = []
+            for return_arg in self.underlying_function.returns:
+                # For each named return variable, we add an identifier to the tuple.
+                if return_arg.name != "":
+                    (refId, refSrc, refType) = next(
+                        (ret["id"], ret["src"], ret["typeDescriptions"])
+                        for ret in self._returnsNotParsed
+                        if ret["name"] == return_arg.name
+                    )
+                    type_ids.append(refType["typeIdentifier"])
+                    type_strs.append(refType["typeString"])
+                    expression["components"].append(
+                        {
+                            "name": return_arg.name,
+                            "nodeType": "Identifier",
+                            "overloadedDeclarations": [],
+                            "referencedDeclaration": refId,
+                            "src": refSrc,
+                            "typeDescriptions": refType,
+                        }
+                    )
+            expression["typeDescriptions"]["typeIdentifier"] = (
+                "t_tuple$_" + "_$_".join(type_ids) + "_$"
+            )
+            expression["typeDescriptions"]["typeString"] = "tuple(" + ",".join(type_strs) + ")"
+            return_node.add_unparsed_expression(expression)
+
+    def _add_return_exp_legacy(self, return_node: NodeSolc, return_params: Dict) -> None:
+        if len(self.underlying_function.returns) == 1:
+            return_arg = self.underlying_function.returns[0]
+            if return_arg.name != "":
+                (refSrc, refType) = next(
+                    (ret["src"], ret["attributes"]["type"])
+                    for ret in self._returnsNotParsed
+                    if ret["attributes"]["name"] == return_arg.name
+                )
+                return_node.add_unparsed_expression(
+                    {
+                        "attributes": {"type": refType, "value": return_arg.name},
+                        "name": "Identifier",
+                        "src": refSrc,
+                    }
+                )
+        else:
+            expression = {
+                "children": [],
+                "name": "TupleExpression",
+                "src": return_params["src"],
+            }
+            for return_arg in self.underlying_function.returns:
+                # For each named return variable, we add an identifier to the tuple.
+                if return_arg.name != "":
+                    (refSrc, refType) = next(
+                        (ret["src"], ret["attributes"]["type"])
+                        for ret in self._returnsNotParsed
+                        if ret["attributes"]["name"] == return_arg.name
+                    )
+                    expression["children"].append(
+                        {
+                            "attributes": {"type": refType, "value": return_arg.name},
+                            "name": "Identifier",
+                            "src": refSrc,
+                        }
+                    )
+            return_node.add_unparsed_expression(expression)
+
     # endregion
     ###################################################################################
     ###################################################################################

slither/solc_parsing/declarations/modifier.py

@@ -93,6 +93,8 @@ class ModifierSolc(FunctionSolc):
         self._rewrite_ternary_as_if_else()
         self._remove_alone_endif()
 
+        if self._function.entry_point:
+            self._update_reachability(self._function.entry_point)
         # self._analyze_read_write()
         # self._analyze_calls()
 

slither/solc_parsing/expressions/expression_parsing.py

@@ -614,20 +614,9 @@ def parse_expression(expression: Dict, caller_context: CallerContextExpression)
 
         assert type_name[caller_context.get_key()] == "UserDefinedTypeName"
 
-        if is_compact_ast:
-
-            # Changed introduced in Solidity 0.8
-            # see https://github.com/crytic/slither/issues/794
-
-            # TODO explore more the changes introduced in 0.8 and the usage of pathNode/IdentifierPath
-            if "name" not in type_name:
-                assert "pathNode" in type_name and "name" in type_name["pathNode"]
-                contract_name = type_name["pathNode"]["name"]
-            else:
-                contract_name = type_name["name"]
-        else:
-            contract_name = type_name["attributes"]["name"]
-        new = NewContract(contract_name)
+        contract_type = parse_type(type_name, caller_context)
+        assert isinstance(contract_type, UserDefinedType)
+        new = NewContract(contract_type)
         new.set_offset(src, caller_context.compilation_unit)
         return new