This is page 27 of 103. Use http://codebase.md/cyfrin/aderyn?lines=true&page={x} to view the full context.
# Directory Structure
```
├── .cargo
│ └── config.toml
├── .git-blame-ignore-revs
├── .gitattributes
├── .github
│ ├── images
│ │ ├── aderyn_logo.png
│ │ ├── poweredbycyfrinblack.png
│ │ └── poweredbycyfrinblue.png
│ ├── ISSUE_TEMPLATE
│ │ ├── bug_report.md
│ │ ├── false_positive_issue.md
│ │ └── feature_request.md
│ └── workflows
│ ├── cargo.yml
│ ├── dependencies.yml
│ ├── release.yml
│ ├── reports.yml
│ └── toml.yml
├── .gitignore
├── .gitmodules
├── .vscode
│ └── settings.json
├── aderyn
│ ├── Cargo.toml
│ ├── oranda.json
│ ├── README.md
│ ├── src
│ │ ├── birdsong.rs
│ │ ├── completions.rs
│ │ ├── lib.rs
│ │ ├── lsp.rs
│ │ ├── main.rs
│ │ ├── mcp.rs
│ │ └── panic.rs
│ └── templates
│ └── aderyn.toml
├── aderyn_core
│ ├── .gitignore
│ ├── Cargo.toml
│ ├── README.md
│ ├── src
│ │ ├── ast
│ │ │ ├── ast_nodes.rs
│ │ │ ├── ast.rs
│ │ │ ├── impls
│ │ │ │ ├── ctx
│ │ │ │ │ ├── utils.rs
│ │ │ │ │ └── workspace.rs
│ │ │ │ ├── ctx.rs
│ │ │ │ ├── disp
│ │ │ │ │ ├── blocks.rs
│ │ │ │ │ ├── contracts.rs
│ │ │ │ │ ├── enumerations.rs
│ │ │ │ │ ├── errors.rs
│ │ │ │ │ ├── events.rs
│ │ │ │ │ ├── expressions.rs
│ │ │ │ │ ├── functions.rs
│ │ │ │ │ ├── identifiers.rs
│ │ │ │ │ ├── literals.rs
│ │ │ │ │ ├── modifiers.rs
│ │ │ │ │ ├── statements.rs
│ │ │ │ │ ├── structures.rs
│ │ │ │ │ ├── types.rs
│ │ │ │ │ ├── user_defined_value_types.rs
│ │ │ │ │ ├── using_for_directives.rs
│ │ │ │ │ └── variables.rs
│ │ │ │ ├── disp.rs
│ │ │ │ ├── node
│ │ │ │ │ ├── blocks.rs
│ │ │ │ │ ├── contracts.rs
│ │ │ │ │ ├── documentation.rs
│ │ │ │ │ ├── enumerations.rs
│ │ │ │ │ ├── errors.rs
│ │ │ │ │ ├── events.rs
│ │ │ │ │ ├── expressions.rs
│ │ │ │ │ ├── functions.rs
│ │ │ │ │ ├── identifiers.rs
│ │ │ │ │ ├── import_directives.rs
│ │ │ │ │ ├── literals.rs
│ │ │ │ │ ├── modifiers.rs
│ │ │ │ │ ├── pragma_directives.rs
│ │ │ │ │ ├── source_units.rs
│ │ │ │ │ ├── statements.rs
│ │ │ │ │ ├── structures.rs
│ │ │ │ │ ├── types.rs
│ │ │ │ │ ├── user_defined_value_types.rs
│ │ │ │ │ ├── using_for_directives.rs
│ │ │ │ │ └── variables.rs
│ │ │ │ ├── node.rs
│ │ │ │ ├── own
│ │ │ │ │ ├── hashing.rs
│ │ │ │ │ ├── node_id.rs
│ │ │ │ │ ├── source_units.rs
│ │ │ │ │ └── utils.rs
│ │ │ │ └── own.rs
│ │ │ ├── impls.rs
│ │ │ ├── macros.rs
│ │ │ ├── magic.rs
│ │ │ ├── node_type.rs
│ │ │ └── yul.rs
│ │ ├── ast.rs
│ │ ├── audit
│ │ │ ├── attack_surface.rs
│ │ │ ├── auditor.rs
│ │ │ ├── entrypoint.rs
│ │ │ └── public_functions_no_sender.rs
│ │ ├── audit.rs
│ │ ├── context
│ │ │ ├── browser
│ │ │ │ ├── ancestral_line.rs
│ │ │ │ ├── closest_ancestor.rs
│ │ │ │ ├── external_calls.rs
│ │ │ │ ├── extractor.rs
│ │ │ │ ├── immediate_children.rs
│ │ │ │ ├── location.rs
│ │ │ │ ├── macros.rs
│ │ │ │ ├── parent.rs
│ │ │ │ ├── peek_over.rs
│ │ │ │ ├── peek_under.rs
│ │ │ │ ├── peek.rs
│ │ │ │ ├── siblings.rs
│ │ │ │ ├── sort_nodes.rs
│ │ │ │ └── storage_vars.rs
│ │ │ ├── browser.rs
│ │ │ ├── capturable.rs
│ │ │ ├── flow
│ │ │ │ ├── display.rs
│ │ │ │ ├── error.rs
│ │ │ │ ├── kind.rs
│ │ │ │ ├── primitives.rs
│ │ │ │ ├── reducibles.rs
│ │ │ │ ├── tests.rs
│ │ │ │ ├── utils.rs
│ │ │ │ ├── visualizer.rs
│ │ │ │ └── voids.rs
│ │ │ ├── flow.rs
│ │ │ ├── graph
│ │ │ │ ├── callgraph
│ │ │ │ │ ├── legacy.rs
│ │ │ │ │ ├── new.rs
│ │ │ │ │ ├── tests.rs
│ │ │ │ │ ├── utils.rs
│ │ │ │ │ └── visit.rs
│ │ │ │ ├── callgraph.rs
│ │ │ │ ├── preprocess
│ │ │ │ │ ├── legacy.rs
│ │ │ │ │ └── new.rs
│ │ │ │ ├── preprocess.rs
│ │ │ │ ├── traits.rs
│ │ │ │ └── utils.rs
│ │ │ ├── graph.rs
│ │ │ ├── macros.rs
│ │ │ ├── mcp
│ │ │ │ ├── callgraph
│ │ │ │ │ ├── render.rs
│ │ │ │ │ ├── tool.rs
│ │ │ │ │ └── utils.rs
│ │ │ │ ├── callgraph.rs
│ │ │ │ ├── contract_surface
│ │ │ │ │ ├── render.rs
│ │ │ │ │ ├── tool.rs
│ │ │ │ │ └── util.rs
│ │ │ │ ├── contract_surface.rs
│ │ │ │ ├── list_contracts
│ │ │ │ │ ├── render.rs
│ │ │ │ │ └── tool.rs
│ │ │ │ ├── list_contracts.rs
│ │ │ │ ├── node_finder
│ │ │ │ │ ├── render.rs
│ │ │ │ │ ├── tool.rs
│ │ │ │ │ └── utils.rs
│ │ │ │ ├── node_finder.rs
│ │ │ │ ├── node_summarizer
│ │ │ │ │ ├── render.rs
│ │ │ │ │ ├── tool.rs
│ │ │ │ │ └── utils.rs
│ │ │ │ ├── node_summarizer.rs
│ │ │ │ ├── project_overview
│ │ │ │ │ ├── render.rs
│ │ │ │ │ └── tool.rs
│ │ │ │ ├── project_overview.rs
│ │ │ │ ├── tool_guide
│ │ │ │ │ └── tool.rs
│ │ │ │ └── tool_guide.rs
│ │ │ ├── mcp.rs
│ │ │ ├── router
│ │ │ │ ├── external_calls.rs
│ │ │ │ ├── internal_calls.rs
│ │ │ │ ├── modifier_calls.rs
│ │ │ │ └── tests.rs
│ │ │ ├── router.rs
│ │ │ └── workspace.rs
│ │ ├── context.rs
│ │ ├── detect
│ │ │ ├── detector.rs
│ │ │ ├── entrypoint.rs
│ │ │ ├── helpers.rs
│ │ │ ├── high
│ │ │ │ ├── _template.rs
│ │ │ │ ├── abi_encode_packed_hash_collision.rs
│ │ │ │ ├── arbitrary_transfer_from.rs
│ │ │ │ ├── const_func_changes_state.rs
│ │ │ │ ├── contract_locks_ether.rs
│ │ │ │ ├── dangerous_unary_operator.rs
│ │ │ │ ├── delegate_call_unchecked_address.rs
│ │ │ │ ├── delete_nested_mapping.rs
│ │ │ │ ├── dynamic_array_length_assignment.rs
│ │ │ │ ├── enumerable_loop_removal.rs
│ │ │ │ ├── eth_send_unchecked_address.rs
│ │ │ │ ├── experimental_encoder.rs
│ │ │ │ ├── function_selector_collision.rs
│ │ │ │ ├── incorrect_caret_operator.rs
│ │ │ │ ├── incorrect_erc20_interface.rs
│ │ │ │ ├── incorrect_erc721_interface.rs
│ │ │ │ ├── incorrect_shift_order.rs
│ │ │ │ ├── misused_boolean.rs
│ │ │ │ ├── msg_value_in_loops.rs
│ │ │ │ ├── multiple_constructors.rs
│ │ │ │ ├── nested_struct_in_mapping.rs
│ │ │ │ ├── out_of_order_retryable.rs
│ │ │ │ ├── pre_declared_variable_usage.rs
│ │ │ │ ├── reentrancy_state_change.rs
│ │ │ │ ├── reused_contract_name.rs
│ │ │ │ ├── rtlo.rs
│ │ │ │ ├── selfdestruct.rs
│ │ │ │ ├── signed_integer_storage_array.rs
│ │ │ │ ├── state_variable_shadowing.rs
│ │ │ │ ├── storage_array_memory_edit.rs
│ │ │ │ ├── strict_equality_contract_balance.rs
│ │ │ │ ├── tautological_compare.rs
│ │ │ │ ├── tautology_or_contradiction.rs
│ │ │ │ ├── tx_origin_used_for_auth.rs
│ │ │ │ ├── unchecked_low_level_call.rs
│ │ │ │ ├── unchecked_send.rs
│ │ │ │ ├── unprotected_initializer.rs
│ │ │ │ ├── unsafe_casting.rs
│ │ │ │ ├── weak_randomness.rs
│ │ │ │ └── yul_return.rs
│ │ │ ├── high.rs
│ │ │ ├── low
│ │ │ │ ├── _template.rs
│ │ │ │ ├── assert_state_change.rs
│ │ │ │ ├── block_timestamp_deadline.rs
│ │ │ │ ├── boolean_equality.rs
│ │ │ │ ├── builtin_symbol_shadowing.rs
│ │ │ │ ├── centralization_risk.rs
│ │ │ │ ├── constant_function_contains_assembly.rs
│ │ │ │ ├── costly_loop.rs
│ │ │ │ ├── dead_code.rs
│ │ │ │ ├── delegatecall_in_loop.rs
│ │ │ │ ├── deprecated_oz_function.rs
│ │ │ │ ├── division_before_multiplication.rs
│ │ │ │ ├── ecrecover.rs
│ │ │ │ ├── empty_block.rs
│ │ │ │ ├── empty_require_revert.rs
│ │ │ │ ├── function_initializing_state.rs
│ │ │ │ ├── function_pointer_in_constructor.rs
│ │ │ │ ├── inconsistent_type_names.rs
│ │ │ │ ├── incorrect_modifier.rs
│ │ │ │ ├── internal_function_used_once.rs
│ │ │ │ ├── large_numeric_literal.rs
│ │ │ │ ├── literal_instead_of_constant.rs
│ │ │ │ ├── local_variable_shadowing.rs
│ │ │ │ ├── missing_inheritance.rs
│ │ │ │ ├── modifier_used_only_once.rs
│ │ │ │ ├── multiple_placeholders.rs
│ │ │ │ ├── non_reentrant_not_first.rs
│ │ │ │ ├── push_0_opcode.rs
│ │ │ │ ├── redundant_statement.rs
│ │ │ │ ├── require_revert_in_loop.rs
│ │ │ │ ├── return_bomb.rs
│ │ │ │ ├── solmate_safe_transfer_lib.rs
│ │ │ │ ├── state_change_without_event.rs
│ │ │ │ ├── state_no_address_check.rs
│ │ │ │ ├── state_variable_could_be_constant.rs
│ │ │ │ ├── state_variable_could_be_immutable.rs
│ │ │ │ ├── state_variable_read_external.rs
│ │ │ │ ├── storage_array_length_not_cached.rs
│ │ │ │ ├── todo.rs
│ │ │ │ ├── unchecked_return.rs
│ │ │ │ ├── uninitialized_local_variable.rs
│ │ │ │ ├── unsafe_erc20_operation.rs
│ │ │ │ ├── unsafe_oz_erc721_mint.rs
│ │ │ │ ├── unspecific_solidity_pragma.rs
│ │ │ │ ├── unused_error.rs
│ │ │ │ ├── unused_import.rs
│ │ │ │ ├── unused_public_function.rs
│ │ │ │ ├── unused_state_variable.rs
│ │ │ │ └── void_constructor.rs
│ │ │ ├── low.rs
│ │ │ └── test_utils.rs
│ │ ├── detect.rs
│ │ ├── lib.rs
│ │ ├── stats
│ │ │ ├── cloc.rs
│ │ │ ├── dbg_tips.txt
│ │ │ ├── ignore.rs
│ │ │ ├── token.rs
│ │ │ └── util.rs
│ │ ├── stats.rs
│ │ ├── test_utils
│ │ │ └── load_source_unit.rs
│ │ ├── test_utils.rs
│ │ ├── visitor
│ │ │ ├── ast_visitor.rs
│ │ │ ├── macros.rs
│ │ │ └── workspace_visitor.rs
│ │ └── visitor.rs
│ ├── templates
│ │ └── mcp-tool-response
│ │ ├── callgraph.md
│ │ ├── contract_surface.md
│ │ ├── list_contracts.md
│ │ ├── node_finder_get_all.md
│ │ ├── node_finder_grep.md
│ │ ├── node_finder_search.md
│ │ ├── node_summarizer.md
│ │ ├── project_overview.md
│ │ └── tool_guide.md
│ └── tests
│ ├── common
│ │ ├── ancestral_line.rs
│ │ ├── closest_ancestor.rs
│ │ ├── immediate_children.rs
│ │ ├── immediate_parent.rs
│ │ ├── mod.rs
│ │ ├── new_ast_nodes.rs
│ │ ├── peek_over.rs
│ │ └── sibling.rs
│ └── traversal.rs
├── aderyn_driver
│ ├── .gitignore
│ ├── benches
│ │ └── detectors.rs
│ ├── Cargo.toml
│ ├── README.md
│ ├── src
│ │ ├── compile.rs
│ │ ├── config.rs
│ │ ├── display.rs
│ │ ├── driver.rs
│ │ ├── interface
│ │ │ ├── json.rs
│ │ │ ├── lsp.rs
│ │ │ ├── markdown.rs
│ │ │ ├── mod.rs
│ │ │ ├── sarif.rs
│ │ │ ├── tables.rs
│ │ │ └── util.rs
│ │ ├── lib.rs
│ │ ├── mcp.rs
│ │ ├── process.rs
│ │ └── runner.rs
│ └── tests
│ └── astgen.rs
├── bacon.toml
├── benchmarks
│ ├── aderyn
│ │ ├── base
│ │ │ ├── benchmark.json
│ │ │ ├── estimates.json
│ │ │ ├── sample.json
│ │ │ └── tukey.json
│ │ ├── change
│ │ │ └── estimates.json
│ │ ├── new
│ │ │ ├── benchmark.json
│ │ │ ├── estimates.json
│ │ │ ├── sample.json
│ │ │ └── tukey.json
│ │ └── report
│ │ ├── both
│ │ │ ├── iteration_times.svg
│ │ │ └── pdf.svg
│ │ ├── change
│ │ │ ├── mean.svg
│ │ │ ├── median.svg
│ │ │ └── t-test.svg
│ │ ├── index.html
│ │ ├── iteration_times_small.svg
│ │ ├── iteration_times.svg
│ │ ├── MAD.svg
│ │ ├── mean.svg
│ │ ├── median.svg
│ │ ├── pdf_small.svg
│ │ ├── pdf.svg
│ │ ├── relative_iteration_times_small.svg
│ │ ├── relative_pdf_small.svg
│ │ ├── SD.svg
│ │ └── typical.svg
│ ├── arbitrary-transfer-from
│ │ ├── base
│ │ │ ├── benchmark.json
│ │ │ ├── estimates.json
│ │ │ ├── sample.json
│ │ │ └── tukey.json
│ │ ├── change
│ │ │ └── estimates.json
│ │ ├── new
│ │ │ ├── benchmark.json
│ │ │ ├── estimates.json
│ │ │ ├── sample.json
│ │ │ └── tukey.json
│ │ └── report
│ │ ├── both
│ │ │ ├── pdf.svg
│ │ │ └── regression.svg
│ │ ├── change
│ │ │ ├── mean.svg
│ │ │ ├── median.svg
│ │ │ └── t-test.svg
│ │ ├── index.html
│ │ ├── MAD.svg
│ │ ├── mean.svg
│ │ ├── median.svg
│ │ ├── pdf_small.svg
│ │ ├── pdf.svg
│ │ ├── regression_small.svg
│ │ ├── regression.svg
│ │ ├── relative_pdf_small.svg
│ │ ├── relative_regression_small.svg
│ │ ├── SD.svg
│ │ ├── slope.svg
│ │ └── typical.svg
│ ├── avoid-abi-encode-packed
│ │ ├── base
│ │ │ ├── benchmark.json
│ │ │ ├── estimates.json
│ │ │ ├── sample.json
│ │ │ └── tukey.json
│ │ ├── change
│ │ │ └── estimates.json
│ │ ├── new
│ │ │ ├── benchmark.json
│ │ │ ├── estimates.json
│ │ │ ├── sample.json
│ │ │ └── tukey.json
│ │ └── report
│ │ ├── both
│ │ │ ├── pdf.svg
│ │ │ └── regression.svg
│ │ ├── change
│ │ │ ├── mean.svg
│ │ │ ├── median.svg
│ │ │ └── t-test.svg
│ │ ├── index.html
│ │ ├── MAD.svg
│ │ ├── mean.svg
│ │ ├── median.svg
│ │ ├── pdf_small.svg
│ │ ├── pdf.svg
│ │ ├── regression_small.svg
│ │ ├── regression.svg
│ │ ├── relative_pdf_small.svg
│ │ ├── relative_regression_small.svg
│ │ ├── SD.svg
│ │ ├── slope.svg
│ │ └── typical.svg
│ ├── block-timestamp-deadline
│ │ ├── base
│ │ │ ├── benchmark.json
│ │ │ ├── estimates.json
│ │ │ ├── sample.json
│ │ │ └── tukey.json
│ │ ├── change
│ │ │ └── estimates.json
│ │ ├── new
│ │ │ ├── benchmark.json
│ │ │ ├── estimates.json
│ │ │ ├── sample.json
│ │ │ └── tukey.json
│ │ └── report
│ │ ├── both
│ │ │ ├── pdf.svg
│ │ │ └── regression.svg
│ │ ├── change
│ │ │ ├── mean.svg
│ │ │ ├── median.svg
│ │ │ └── t-test.svg
│ │ ├── index.html
│ │ ├── MAD.svg
│ │ ├── mean.svg
│ │ ├── median.svg
│ │ ├── pdf_small.svg
│ │ ├── pdf.svg
│ │ ├── regression_small.svg
│ │ ├── regression.svg
│ │ ├── relative_pdf_small.svg
│ │ ├── relative_regression_small.svg
│ │ ├── SD.svg
│ │ ├── slope.svg
│ │ └── typical.svg
│ ├── centralization-risk
│ │ ├── base
│ │ │ ├── benchmark.json
│ │ │ ├── estimates.json
│ │ │ ├── sample.json
│ │ │ └── tukey.json
│ │ ├── change
│ │ │ └── estimates.json
│ │ ├── new
│ │ │ ├── benchmark.json
│ │ │ ├── estimates.json
│ │ │ ├── sample.json
│ │ │ └── tukey.json
│ │ └── report
│ │ ├── both
│ │ │ ├── pdf.svg
│ │ │ └── regression.svg
│ │ ├── change
│ │ │ ├── mean.svg
│ │ │ ├── median.svg
│ │ │ └── t-test.svg
│ │ ├── index.html
│ │ ├── MAD.svg
│ │ ├── mean.svg
│ │ ├── median.svg
│ │ ├── pdf_small.svg
│ │ ├── pdf.svg
│ │ ├── regression_small.svg
│ │ ├── regression.svg
│ │ ├── relative_pdf_small.svg
│ │ ├── relative_regression_small.svg
│ │ ├── SD.svg
│ │ ├── slope.svg
│ │ └── typical.svg
│ ├── constants-instead-of-literals
│ │ ├── base
│ │ │ ├── benchmark.json
│ │ │ ├── estimates.json
│ │ │ ├── sample.json
│ │ │ └── tukey.json
│ │ ├── change
│ │ │ └── estimates.json
│ │ ├── new
│ │ │ ├── benchmark.json
│ │ │ ├── estimates.json
│ │ │ ├── sample.json
│ │ │ └── tukey.json
│ │ └── report
│ │ ├── both
│ │ │ ├── pdf.svg
│ │ │ └── regression.svg
│ │ ├── change
│ │ │ ├── mean.svg
│ │ │ ├── median.svg
│ │ │ └── t-test.svg
│ │ ├── index.html
│ │ ├── MAD.svg
│ │ ├── mean.svg
│ │ ├── median.svg
│ │ ├── pdf_small.svg
│ │ ├── pdf.svg
│ │ ├── regression_small.svg
│ │ ├── regression.svg
│ │ ├── relative_pdf_small.svg
│ │ ├── relative_regression_small.svg
│ │ ├── SD.svg
│ │ ├── slope.svg
│ │ └── typical.svg
│ ├── delegate-call-in-loop
│ │ ├── base
│ │ │ ├── benchmark.json
│ │ │ ├── estimates.json
│ │ │ ├── sample.json
│ │ │ └── tukey.json
│ │ ├── change
│ │ │ └── estimates.json
│ │ ├── new
│ │ │ ├── benchmark.json
│ │ │ ├── estimates.json
│ │ │ ├── sample.json
│ │ │ └── tukey.json
│ │ └── report
│ │ ├── both
│ │ │ ├── pdf.svg
│ │ │ └── regression.svg
│ │ ├── change
│ │ │ ├── mean.svg
│ │ │ ├── median.svg
│ │ │ └── t-test.svg
│ │ ├── index.html
│ │ ├── MAD.svg
│ │ ├── mean.svg
│ │ ├── median.svg
│ │ ├── pdf_small.svg
│ │ ├── pdf.svg
│ │ ├── regression_small.svg
│ │ ├── regression.svg
│ │ ├── relative_pdf_small.svg
│ │ ├── relative_regression_small.svg
│ │ ├── SD.svg
│ │ ├── slope.svg
│ │ └── typical.svg
│ ├── deprecated-oz-functions
│ │ ├── base
│ │ │ ├── benchmark.json
│ │ │ ├── estimates.json
│ │ │ ├── sample.json
│ │ │ └── tukey.json
│ │ ├── change
│ │ │ └── estimates.json
│ │ ├── new
│ │ │ ├── benchmark.json
│ │ │ ├── estimates.json
│ │ │ ├── sample.json
│ │ │ └── tukey.json
│ │ └── report
│ │ ├── both
│ │ │ ├── pdf.svg
│ │ │ └── regression.svg
│ │ ├── change
│ │ │ ├── mean.svg
│ │ │ ├── median.svg
│ │ │ └── t-test.svg
│ │ ├── index.html
│ │ ├── MAD.svg
│ │ ├── mean.svg
│ │ ├── median.svg
│ │ ├── pdf_small.svg
│ │ ├── pdf.svg
│ │ ├── regression_small.svg
│ │ ├── regression.svg
│ │ ├── relative_pdf_small.svg
│ │ ├── relative_regression_small.svg
│ │ ├── SD.svg
│ │ ├── slope.svg
│ │ └── typical.svg
│ ├── ecrecover
│ │ ├── base
│ │ │ ├── benchmark.json
│ │ │ ├── estimates.json
│ │ │ ├── sample.json
│ │ │ └── tukey.json
│ │ ├── change
│ │ │ └── estimates.json
│ │ ├── new
│ │ │ ├── benchmark.json
│ │ │ ├── estimates.json
│ │ │ ├── sample.json
│ │ │ └── tukey.json
│ │ └── report
│ │ ├── both
│ │ │ ├── pdf.svg
│ │ │ └── regression.svg
│ │ ├── change
│ │ │ ├── mean.svg
│ │ │ ├── median.svg
│ │ │ └── t-test.svg
│ │ ├── index.html
│ │ ├── MAD.svg
│ │ ├── mean.svg
│ │ ├── median.svg
│ │ ├── pdf_small.svg
│ │ ├── pdf.svg
│ │ ├── regression_small.svg
│ │ ├── regression.svg
│ │ ├── relative_pdf_small.svg
│ │ ├── relative_regression_small.svg
│ │ ├── SD.svg
│ │ ├── slope.svg
│ │ └── typical.svg
│ ├── empty-block
│ │ ├── base
│ │ │ ├── benchmark.json
│ │ │ ├── estimates.json
│ │ │ ├── sample.json
│ │ │ └── tukey.json
│ │ ├── change
│ │ │ └── estimates.json
│ │ ├── new
│ │ │ ├── benchmark.json
│ │ │ ├── estimates.json
│ │ │ ├── sample.json
│ │ │ └── tukey.json
│ │ └── report
│ │ ├── both
│ │ │ ├── pdf.svg
│ │ │ └── regression.svg
│ │ ├── change
│ │ │ ├── mean.svg
│ │ │ ├── median.svg
│ │ │ └── t-test.svg
│ │ ├── index.html
│ │ ├── MAD.svg
│ │ ├── mean.svg
│ │ ├── median.svg
│ │ ├── pdf_small.svg
│ │ ├── pdf.svg
│ │ ├── regression_small.svg
│ │ ├── regression.svg
│ │ ├── relative_pdf_small.svg
│ │ ├── relative_regression_small.svg
│ │ ├── SD.svg
│ │ ├── slope.svg
│ │ └── typical.svg
│ ├── hello_world
│ │ ├── base
│ │ │ ├── benchmark.json
│ │ │ ├── estimates.json
│ │ │ ├── sample.json
│ │ │ └── tukey.json
│ │ ├── new
│ │ │ ├── benchmark.json
│ │ │ ├── estimates.json
│ │ │ ├── sample.json
│ │ │ └── tukey.json
│ │ └── report
│ │ ├── index.html
│ │ ├── MAD.svg
│ │ ├── mean.svg
│ │ ├── median.svg
│ │ ├── pdf_small.svg
│ │ ├── pdf.svg
│ │ ├── regression_small.svg
│ │ ├── regression.svg
│ │ ├── SD.svg
│ │ ├── slope.svg
│ │ └── typical.svg
│ ├── inconsistent-type-names
│ │ ├── base
│ │ │ ├── benchmark.json
│ │ │ ├── estimates.json
│ │ │ ├── sample.json
│ │ │ └── tukey.json
│ │ ├── change
│ │ │ └── estimates.json
│ │ ├── new
│ │ │ ├── benchmark.json
│ │ │ ├── estimates.json
│ │ │ ├── sample.json
│ │ │ └── tukey.json
│ │ └── report
│ │ ├── both
│ │ │ ├── pdf.svg
│ │ │ └── regression.svg
│ │ ├── change
│ │ │ ├── mean.svg
│ │ │ ├── median.svg
│ │ │ └── t-test.svg
│ │ ├── index.html
│ │ ├── MAD.svg
│ │ ├── mean.svg
│ │ ├── median.svg
│ │ ├── pdf_small.svg
│ │ ├── pdf.svg
│ │ ├── regression_small.svg
│ │ ├── regression.svg
│ │ ├── relative_pdf_small.svg
│ │ ├── relative_regression_small.svg
│ │ ├── SD.svg
│ │ ├── slope.svg
│ │ └── typical.svg
│ ├── large-numeric-literal
│ │ ├── base
│ │ │ ├── benchmark.json
│ │ │ ├── estimates.json
│ │ │ ├── sample.json
│ │ │ └── tukey.json
│ │ ├── change
│ │ │ └── estimates.json
│ │ ├── new
│ │ │ ├── benchmark.json
│ │ │ ├── estimates.json
│ │ │ ├── sample.json
│ │ │ └── tukey.json
│ │ └── report
│ │ ├── both
│ │ │ ├── pdf.svg
│ │ │ └── regression.svg
│ │ ├── change
│ │ │ ├── mean.svg
│ │ │ ├── median.svg
│ │ │ └── t-test.svg
│ │ ├── index.html
│ │ ├── MAD.svg
│ │ ├── mean.svg
│ │ ├── median.svg
│ │ ├── pdf_small.svg
│ │ ├── pdf.svg
│ │ ├── regression_small.svg
│ │ ├── regression.svg
│ │ ├── relative_pdf_small.svg
│ │ ├── relative_regression_small.svg
│ │ ├── SD.svg
│ │ ├── slope.svg
│ │ └── typical.svg
│ ├── non-reentrant-before-others
│ │ ├── base
│ │ │ ├── benchmark.json
│ │ │ ├── estimates.json
│ │ │ ├── sample.json
│ │ │ └── tukey.json
│ │ ├── change
│ │ │ └── estimates.json
│ │ ├── new
│ │ │ ├── benchmark.json
│ │ │ ├── estimates.json
│ │ │ ├── sample.json
│ │ │ └── tukey.json
│ │ └── report
│ │ ├── both
│ │ │ ├── pdf.svg
│ │ │ └── regression.svg
│ │ ├── change
│ │ │ ├── mean.svg
│ │ │ ├── median.svg
│ │ │ └── t-test.svg
│ │ ├── index.html
│ │ ├── MAD.svg
│ │ ├── mean.svg
│ │ ├── median.svg
│ │ ├── pdf_small.svg
│ │ ├── pdf.svg
│ │ ├── regression_small.svg
│ │ ├── regression.svg
│ │ ├── relative_pdf_small.svg
│ │ ├── relative_regression_small.svg
│ │ ├── SD.svg
│ │ ├── slope.svg
│ │ └── typical.svg
│ ├── push-zero-opcode
│ │ ├── base
│ │ │ ├── benchmark.json
│ │ │ ├── estimates.json
│ │ │ ├── sample.json
│ │ │ └── tukey.json
│ │ ├── change
│ │ │ └── estimates.json
│ │ ├── new
│ │ │ ├── benchmark.json
│ │ │ ├── estimates.json
│ │ │ ├── sample.json
│ │ │ └── tukey.json
│ │ └── report
│ │ ├── both
│ │ │ ├── pdf.svg
│ │ │ └── regression.svg
│ │ ├── change
│ │ │ ├── mean.svg
│ │ │ ├── median.svg
│ │ │ └── t-test.svg
│ │ ├── index.html
│ │ ├── MAD.svg
│ │ ├── mean.svg
│ │ ├── median.svg
│ │ ├── pdf_small.svg
│ │ ├── pdf.svg
│ │ ├── regression_small.svg
│ │ ├── regression.svg
│ │ ├── relative_pdf_small.svg
│ │ ├── relative_regression_small.svg
│ │ ├── SD.svg
│ │ ├── slope.svg
│ │ └── typical.svg
│ ├── report
│ │ └── index.html
│ ├── require-with-string
│ │ ├── base
│ │ │ ├── benchmark.json
│ │ │ ├── estimates.json
│ │ │ ├── sample.json
│ │ │ └── tukey.json
│ │ ├── change
│ │ │ └── estimates.json
│ │ ├── new
│ │ │ ├── benchmark.json
│ │ │ ├── estimates.json
│ │ │ ├── sample.json
│ │ │ └── tukey.json
│ │ └── report
│ │ ├── both
│ │ │ ├── pdf.svg
│ │ │ └── regression.svg
│ │ ├── change
│ │ │ ├── mean.svg
│ │ │ ├── median.svg
│ │ │ └── t-test.svg
│ │ ├── index.html
│ │ ├── MAD.svg
│ │ ├── mean.svg
│ │ ├── median.svg
│ │ ├── pdf_small.svg
│ │ ├── pdf.svg
│ │ ├── regression_small.svg
│ │ ├── regression.svg
│ │ ├── relative_pdf_small.svg
│ │ ├── relative_regression_small.svg
│ │ ├── SD.svg
│ │ ├── slope.svg
│ │ └── typical.svg
│ ├── solmate-safe-transfer-lib
│ │ ├── base
│ │ │ ├── benchmark.json
│ │ │ ├── estimates.json
│ │ │ ├── sample.json
│ │ │ └── tukey.json
│ │ ├── change
│ │ │ └── estimates.json
│ │ ├── new
│ │ │ ├── benchmark.json
│ │ │ ├── estimates.json
│ │ │ ├── sample.json
│ │ │ └── tukey.json
│ │ └── report
│ │ ├── both
│ │ │ ├── pdf.svg
│ │ │ └── regression.svg
│ │ ├── change
│ │ │ ├── mean.svg
│ │ │ ├── median.svg
│ │ │ └── t-test.svg
│ │ ├── index.html
│ │ ├── MAD.svg
│ │ ├── mean.svg
│ │ ├── median.svg
│ │ ├── pdf_small.svg
│ │ ├── pdf.svg
│ │ ├── regression_small.svg
│ │ ├── regression.svg
│ │ ├── relative_pdf_small.svg
│ │ ├── relative_regression_small.svg
│ │ ├── SD.svg
│ │ ├── slope.svg
│ │ └── typical.svg
│ ├── unindexed-events
│ │ ├── base
│ │ │ ├── benchmark.json
│ │ │ ├── estimates.json
│ │ │ ├── sample.json
│ │ │ └── tukey.json
│ │ ├── change
│ │ │ └── estimates.json
│ │ ├── new
│ │ │ ├── benchmark.json
│ │ │ ├── estimates.json
│ │ │ ├── sample.json
│ │ │ └── tukey.json
│ │ └── report
│ │ ├── both
│ │ │ ├── pdf.svg
│ │ │ └── regression.svg
│ │ ├── change
│ │ │ ├── mean.svg
│ │ │ ├── median.svg
│ │ │ └── t-test.svg
│ │ ├── index.html
│ │ ├── MAD.svg
│ │ ├── mean.svg
│ │ ├── median.svg
│ │ ├── pdf_small.svg
│ │ ├── pdf.svg
│ │ ├── regression_small.svg
│ │ ├── regression.svg
│ │ ├── relative_pdf_small.svg
│ │ ├── relative_regression_small.svg
│ │ ├── SD.svg
│ │ ├── slope.svg
│ │ └── typical.svg
│ ├── unprotected-initializer
│ │ ├── base
│ │ │ ├── benchmark.json
│ │ │ ├── estimates.json
│ │ │ ├── sample.json
│ │ │ └── tukey.json
│ │ ├── change
│ │ │ └── estimates.json
│ │ ├── new
│ │ │ ├── benchmark.json
│ │ │ ├── estimates.json
│ │ │ ├── sample.json
│ │ │ └── tukey.json
│ │ └── report
│ │ ├── both
│ │ │ ├── pdf.svg
│ │ │ └── regression.svg
│ │ ├── change
│ │ │ ├── mean.svg
│ │ │ ├── median.svg
│ │ │ └── t-test.svg
│ │ ├── index.html
│ │ ├── MAD.svg
│ │ ├── mean.svg
│ │ ├── median.svg
│ │ ├── pdf_small.svg
│ │ ├── pdf.svg
│ │ ├── regression_small.svg
│ │ ├── regression.svg
│ │ ├── relative_pdf_small.svg
│ │ ├── relative_regression_small.svg
│ │ ├── SD.svg
│ │ ├── slope.svg
│ │ └── typical.svg
│ ├── unsafe-erc20-functions
│ │ ├── base
│ │ │ ├── benchmark.json
│ │ │ ├── estimates.json
│ │ │ ├── sample.json
│ │ │ └── tukey.json
│ │ ├── change
│ │ │ └── estimates.json
│ │ ├── new
│ │ │ ├── benchmark.json
│ │ │ ├── estimates.json
│ │ │ ├── sample.json
│ │ │ └── tukey.json
│ │ └── report
│ │ ├── both
│ │ │ ├── pdf.svg
│ │ │ └── regression.svg
│ │ ├── change
│ │ │ ├── mean.svg
│ │ │ ├── median.svg
│ │ │ └── t-test.svg
│ │ ├── index.html
│ │ ├── MAD.svg
│ │ ├── mean.svg
│ │ ├── median.svg
│ │ ├── pdf_small.svg
│ │ ├── pdf.svg
│ │ ├── regression_small.svg
│ │ ├── regression.svg
│ │ ├── relative_pdf_small.svg
│ │ ├── relative_regression_small.svg
│ │ ├── SD.svg
│ │ ├── slope.svg
│ │ └── typical.svg
│ ├── unsafe-oz-erc721-mint
│ │ ├── base
│ │ │ ├── benchmark.json
│ │ │ ├── estimates.json
│ │ │ ├── sample.json
│ │ │ └── tukey.json
│ │ ├── change
│ │ │ └── estimates.json
│ │ ├── new
│ │ │ ├── benchmark.json
│ │ │ ├── estimates.json
│ │ │ ├── sample.json
│ │ │ └── tukey.json
│ │ └── report
│ │ ├── both
│ │ │ ├── pdf.svg
│ │ │ └── regression.svg
│ │ ├── change
│ │ │ ├── mean.svg
│ │ │ ├── median.svg
│ │ │ └── t-test.svg
│ │ ├── index.html
│ │ ├── MAD.svg
│ │ ├── mean.svg
│ │ ├── median.svg
│ │ ├── pdf_small.svg
│ │ ├── pdf.svg
│ │ ├── regression_small.svg
│ │ ├── regression.svg
│ │ ├── relative_pdf_small.svg
│ │ ├── relative_regression_small.svg
│ │ ├── SD.svg
│ │ ├── slope.svg
│ │ └── typical.svg
│ ├── unspecific-solidity-pragma
│ │ ├── base
│ │ │ ├── benchmark.json
│ │ │ ├── estimates.json
│ │ │ ├── sample.json
│ │ │ └── tukey.json
│ │ ├── change
│ │ │ └── estimates.json
│ │ ├── new
│ │ │ ├── benchmark.json
│ │ │ ├── estimates.json
│ │ │ ├── sample.json
│ │ │ └── tukey.json
│ │ └── report
│ │ ├── both
│ │ │ ├── pdf.svg
│ │ │ └── regression.svg
│ │ ├── change
│ │ │ ├── mean.svg
│ │ │ ├── median.svg
│ │ │ └── t-test.svg
│ │ ├── index.html
│ │ ├── MAD.svg
│ │ ├── mean.svg
│ │ ├── median.svg
│ │ ├── pdf_small.svg
│ │ ├── pdf.svg
│ │ ├── regression_small.svg
│ │ ├── regression.svg
│ │ ├── relative_pdf_small.svg
│ │ ├── relative_regression_small.svg
│ │ ├── SD.svg
│ │ ├── slope.svg
│ │ └── typical.svg
│ ├── useless-internal-function
│ │ ├── base
│ │ │ ├── benchmark.json
│ │ │ ├── estimates.json
│ │ │ ├── sample.json
│ │ │ └── tukey.json
│ │ ├── change
│ │ │ └── estimates.json
│ │ ├── new
│ │ │ ├── benchmark.json
│ │ │ ├── estimates.json
│ │ │ ├── sample.json
│ │ │ └── tukey.json
│ │ └── report
│ │ ├── both
│ │ │ ├── pdf.svg
│ │ │ └── regression.svg
│ │ ├── change
│ │ │ ├── mean.svg
│ │ │ ├── median.svg
│ │ │ └── t-test.svg
│ │ ├── index.html
│ │ ├── MAD.svg
│ │ ├── mean.svg
│ │ ├── median.svg
│ │ ├── pdf_small.svg
│ │ ├── pdf.svg
│ │ ├── regression_small.svg
│ │ ├── regression.svg
│ │ ├── relative_pdf_small.svg
│ │ ├── relative_regression_small.svg
│ │ ├── SD.svg
│ │ ├── slope.svg
│ │ └── typical.svg
│ ├── useless-modifier
│ │ ├── base
│ │ │ ├── benchmark.json
│ │ │ ├── estimates.json
│ │ │ ├── sample.json
│ │ │ └── tukey.json
│ │ ├── change
│ │ │ └── estimates.json
│ │ ├── new
│ │ │ ├── benchmark.json
│ │ │ ├── estimates.json
│ │ │ ├── sample.json
│ │ │ └── tukey.json
│ │ └── report
│ │ ├── both
│ │ │ ├── pdf.svg
│ │ │ └── regression.svg
│ │ ├── change
│ │ │ ├── mean.svg
│ │ │ ├── median.svg
│ │ │ └── t-test.svg
│ │ ├── index.html
│ │ ├── MAD.svg
│ │ ├── mean.svg
│ │ ├── median.svg
│ │ ├── pdf_small.svg
│ │ ├── pdf.svg
│ │ ├── regression_small.svg
│ │ ├── regression.svg
│ │ ├── relative_pdf_small.svg
│ │ ├── relative_regression_small.svg
│ │ ├── SD.svg
│ │ ├── slope.svg
│ │ └── typical.svg
│ ├── useless-public-function
│ │ ├── base
│ │ │ ├── benchmark.json
│ │ │ ├── estimates.json
│ │ │ ├── sample.json
│ │ │ └── tukey.json
│ │ ├── change
│ │ │ └── estimates.json
│ │ ├── new
│ │ │ ├── benchmark.json
│ │ │ ├── estimates.json
│ │ │ ├── sample.json
│ │ │ └── tukey.json
│ │ └── report
│ │ ├── both
│ │ │ ├── pdf.svg
│ │ │ └── regression.svg
│ │ ├── change
│ │ │ ├── mean.svg
│ │ │ ├── median.svg
│ │ │ └── t-test.svg
│ │ ├── index.html
│ │ ├── MAD.svg
│ │ ├── mean.svg
│ │ ├── median.svg
│ │ ├── pdf_small.svg
│ │ ├── pdf.svg
│ │ ├── regression_small.svg
│ │ ├── regression.svg
│ │ ├── relative_pdf_small.svg
│ │ ├── relative_regression_small.svg
│ │ ├── SD.svg
│ │ ├── slope.svg
│ │ └── typical.svg
│ └── zero-address-check
│ ├── base
│ │ ├── benchmark.json
│ │ ├── estimates.json
│ │ ├── sample.json
│ │ └── tukey.json
│ ├── change
│ │ └── estimates.json
│ ├── new
│ │ ├── benchmark.json
│ │ ├── estimates.json
│ │ ├── sample.json
│ │ └── tukey.json
│ └── report
│ ├── both
│ │ ├── pdf.svg
│ │ └── regression.svg
│ ├── change
│ │ ├── mean.svg
│ │ ├── median.svg
│ │ └── t-test.svg
│ ├── index.html
│ ├── MAD.svg
│ ├── mean.svg
│ ├── median.svg
│ ├── pdf_small.svg
│ ├── pdf.svg
│ ├── regression_small.svg
│ ├── regression.svg
│ ├── relative_pdf_small.svg
│ ├── relative_regression_small.svg
│ ├── SD.svg
│ ├── slope.svg
│ └── typical.svg
├── Cargo.lock
├── Cargo.toml
├── cli
│ ├── benchmarks.sh
│ └── reportgen.sh
├── CODEOWNERS
├── CONTRIBUTING.md
├── cyfrinup
│ ├── dynamic_script
│ └── why.md
├── deny.toml
├── dist-workspace.toml
├── funding.json
├── LICENSE
├── Makefile
├── package-lock.json
├── package.json
├── README.md
├── RELEASE_CHECKLIST.md
├── reports
│ ├── adhoc-sol-files-highs-only-report.json
│ ├── adhoc-sol-files-report.md
│ ├── ccip-functions-report.md
│ ├── empty_report.md
│ ├── hardhat-playground-report.md
│ ├── nft-report-icm.md
│ ├── nft-report.md
│ ├── prb-math-report.md
│ ├── report.json
│ ├── report.md
│ ├── report.sarif
│ ├── sablier-aderyn-toml-nested-root.md
│ ├── templegold-report.md
│ └── uniswap_profile.md
├── rust-toolchain.toml
├── rustfmt.toml
├── tests
│ ├── adhoc-sol-files
│ │ ├── aderyn.toml
│ │ ├── Counter.sol
│ │ ├── DemoASTNodes.sol
│ │ ├── Helper.sol
│ │ ├── InconsistentUints.sol
│ │ ├── inheritance
│ │ │ ├── ExtendedInheritance.sol
│ │ │ ├── IContractInheritance.sol
│ │ │ └── InheritanceBase.sol
│ │ ├── InternalFunctions.sol
│ │ ├── lib
│ │ │ └── ThisShouldBeExcluded.sol
│ │ ├── multiple-versions
│ │ │ ├── 0.4
│ │ │ │ ├── A.sol
│ │ │ │ └── B.sol
│ │ │ ├── 0.5
│ │ │ │ ├── A.sol
│ │ │ │ └── B.sol
│ │ │ ├── 0.6
│ │ │ │ ├── A.sol
│ │ │ │ └── B.sol
│ │ │ ├── 0.7
│ │ │ │ ├── A.sol
│ │ │ │ └── B.sol
│ │ │ └── 0.8
│ │ │ ├── A.sol
│ │ │ └── B.sol
│ │ ├── OnceModifierExample.sol
│ │ └── StateVariables.sol
│ ├── ast
│ │ ├── abstract_contract.json
│ │ ├── address_payable.json
│ │ ├── array_type_name.json
│ │ ├── ast-erc4626.json
│ │ ├── base_constructor_call.json
│ │ ├── bit_not.json
│ │ ├── call.json
│ │ ├── constructor.json
│ │ ├── contract_dep_order.json
│ │ ├── do_while.json
│ │ ├── documentation_1.json
│ │ ├── documentation_2.json
│ │ ├── documentation_3.json
│ │ ├── documentation_local_variable.json
│ │ ├── documentation_on_statements.json
│ │ ├── documentation_triple.json
│ │ ├── empty_block.json
│ │ ├── enum_value_declaration.json
│ │ ├── enum_value.json
│ │ ├── event_definition.json
│ │ ├── experimental_encoder_pragma.json
│ │ ├── fallback_and_reveice_ether.json
│ │ ├── fallback_payable.json
│ │ ├── fallback.json
│ │ ├── function_type.json
│ │ ├── function.json
│ │ ├── global_enum.json
│ │ ├── global_struct.json
│ │ ├── inheritance_specifier.json
│ │ ├── leave.json
│ │ ├── license.json
│ │ ├── long_type_name_binary_operation.json
│ │ ├── long_type_name_identifier.json
│ │ ├── loop.json
│ │ ├── mappings.json
│ │ ├── modifier_definition.json
│ │ ├── modifier_invocation.json
│ │ ├── mutability.json
│ │ ├── nested_functions.json
│ │ ├── non_utf8.json
│ │ ├── override.json
│ │ ├── placeholder_statement.json
│ │ ├── receive_ether.json
│ │ ├── short_type_name_ref.json
│ │ ├── short_type_name.json
│ │ ├── slot_offset.json
│ │ ├── smoke.json
│ │ ├── source_location.json
│ │ ├── string.json
│ │ ├── stringlit.json
│ │ ├── switch_default.json
│ │ ├── switch.json
│ │ ├── try_catch.json
│ │ ├── two_base_functions.json
│ │ ├── unicode.json
│ │ ├── used_errors.json
│ │ ├── userDefinedValueType.json
│ │ ├── using_for_directive.json
│ │ ├── var_access.json
│ │ └── yul_hex_literal.json
│ ├── contract-playground
│ │ ├── .github
│ │ │ └── workflows
│ │ │ └── test.yml
│ │ ├── .gitignore
│ │ ├── dot
│ │ │ └── .gitkeep
│ │ ├── foundry.toml
│ │ ├── README.md
│ │ ├── script
│ │ │ └── Counter.s.sol
│ │ ├── src
│ │ │ ├── AbstractContract.sol
│ │ │ ├── AderynIgnoreCustomDetectors.sol
│ │ │ ├── AdminContract.sol
│ │ │ ├── ArbitraryTransferFrom.sol
│ │ │ ├── AssemblyExample.sol
│ │ │ ├── AssertStateChange.sol
│ │ │ ├── auditor_mode
│ │ │ │ ├── ExternalCalls.sol
│ │ │ │ └── PublicFunctionsWithoutSenderCheck.sol
│ │ │ ├── BooleanEquality.sol
│ │ │ ├── BuiltinSymbolShadow.sol
│ │ │ ├── CacheArrayLength.sol
│ │ │ ├── CallGraphTests.sol
│ │ │ ├── Casting.sol
│ │ │ ├── cloc
│ │ │ │ ├── AnotherHeavilyCommentedContract.sol
│ │ │ │ ├── EmptyContractFile.sol
│ │ │ │ └── HeavilyCommentedContract.sol
│ │ │ ├── CompilerBugStorageSignedIntegerArray.sol
│ │ │ ├── ConstantFuncsAssembly.sol
│ │ │ ├── ConstantsLiterals.sol
│ │ │ ├── ConstFuncChangeState.sol
│ │ │ ├── ContractLocksEther.sol
│ │ │ ├── ContractWithTodo.sol
│ │ │ ├── control_flow
│ │ │ │ └── SimpleProgram.sol
│ │ │ ├── CostlyOperationsInsideLoops.sol
│ │ │ ├── Counter.sol
│ │ │ ├── CrazyPragma.sol
│ │ │ ├── DangerousStrictEquality1.sol
│ │ │ ├── DangerousStrictEquality2.sol
│ │ │ ├── DangerousUnaryOperator.sol
│ │ │ ├── DeadCode.sol
│ │ │ ├── DelegateCallWithoutAddressCheck.sol
│ │ │ ├── DeletionNestedMappingStructureContract.sol
│ │ │ ├── DeprecatedOZFunctions.sol
│ │ │ ├── DivisionBeforeMultiplication.sol
│ │ │ ├── DynamicArrayLengthAssignment.sol
│ │ │ ├── EmitAfterExternalCall.sol
│ │ │ ├── EmptyBlocks.sol
│ │ │ ├── EnumerableSetIteration.sol
│ │ │ ├── eth2
│ │ │ │ └── DepositContract.sol
│ │ │ ├── ExperimentalEncoder.sol
│ │ │ ├── ExternalCalls.sol
│ │ │ ├── FunctionInitializingState.sol
│ │ │ ├── FunctionPointers.sol
│ │ │ ├── FunctionSignatureCollision.sol
│ │ │ ├── HugeConstants.sol
│ │ │ ├── IgnoreEverything.sol
│ │ │ ├── InconsistentUints.sol
│ │ │ ├── IncorrectCaretOperator.sol
│ │ │ ├── IncorrectERC20.sol
│ │ │ ├── IncorrectERC721.sol
│ │ │ ├── IncorrectModifier.sol
│ │ │ ├── IncorrectShift.sol
│ │ │ ├── inheritance
│ │ │ │ ├── ExtendedInheritance.sol
│ │ │ │ ├── IContractInheritance.sol
│ │ │ │ └── InheritanceBase.sol
│ │ │ ├── InternalFunctions.sol
│ │ │ ├── KeccakContract.sol
│ │ │ ├── LocalVariableShadow.sol
│ │ │ ├── MissingInheritance.sol
│ │ │ ├── MisusedBoolean.sol
│ │ │ ├── MsgValueInLoop.sol
│ │ │ ├── MultipleConstructorSchemes.sol
│ │ │ ├── MultiplePlaceholders.sol
│ │ │ ├── nested
│ │ │ │ ├── 1
│ │ │ │ │ └── Nested.sol
│ │ │ │ └── 2
│ │ │ │ └── Nested.sol
│ │ │ ├── nested_mappings
│ │ │ │ ├── LaterVersion.sol
│ │ │ │ └── NestedMappings.sol
│ │ │ ├── OnceModifierExample.sol
│ │ │ ├── OnlyLibrary.sol
│ │ │ ├── OutOfOrderRetryable.sol
│ │ │ ├── parent_chain
│ │ │ │ └── ParentChainContract.sol
│ │ │ ├── PragmaRange.sol
│ │ │ ├── PreDeclaredVarUsage.sol
│ │ │ ├── PublicFunction.sol
│ │ │ ├── PublicVariableReadInExternalContext.sol
│ │ │ ├── RedundantStatements.sol
│ │ │ ├── ReturnBomb.sol
│ │ │ ├── reused_contract_name
│ │ │ │ ├── ContractA.sol
│ │ │ │ └── ContractB.sol
│ │ │ ├── RevertsAndRequriesInLoops.sol
│ │ │ ├── router
│ │ │ │ ├── ExternalCalls.sol
│ │ │ │ ├── FallbackAndReceiveOverrides.sol
│ │ │ │ ├── InternalCalls.sol
│ │ │ │ ├── ModifierCalls.sol
│ │ │ │ └── VarOverridesFunction.sol
│ │ │ ├── RTLO.sol
│ │ │ ├── SendEtherNoChecks.sol
│ │ │ ├── SendEtherNoChecksLibImport.sol
│ │ │ ├── StateChangeAfterExternalCall.sol
│ │ │ ├── StateShadowing.sol
│ │ │ ├── StateVariableCouldBeDeclaredConstant.sol
│ │ │ ├── StateVariableCouldBeDeclaredImmutable.sol
│ │ │ ├── StateVariables.sol
│ │ │ ├── StateVariablesChangesWithoutEvents.sol
│ │ │ ├── StateVariablesManipulation.sol
│ │ │ ├── StorageConditionals.sol
│ │ │ ├── StorageParameters.sol
│ │ │ ├── T11sTranferer.sol
│ │ │ ├── TautologicalCompare.sol
│ │ │ ├── TautologyOrContradiction.sol
│ │ │ ├── TestERC20.sol
│ │ │ ├── TransientKeyword.sol
│ │ │ ├── Trump.sol
│ │ │ ├── TxOriginUsedForAuth.sol
│ │ │ ├── U2.sol
│ │ │ ├── U3.sol
│ │ │ ├── U4.sol
│ │ │ ├── U5.sol
│ │ │ ├── UncheckedCalls.sol
│ │ │ ├── UncheckedReturn.sol
│ │ │ ├── UncheckedSend.sol
│ │ │ ├── UninitializedLocalVariables.sol
│ │ │ ├── UninitializedStateVariable.sol
│ │ │ ├── uniswap
│ │ │ │ ├── UniswapV2Swapper.sol
│ │ │ │ └── UniswapV3Swapper.sol
│ │ │ ├── UnprotectedInitialize.sol
│ │ │ ├── UnsafeERC721Mint.sol
│ │ │ ├── UnusedError.sol
│ │ │ ├── UnusedImport.sol
│ │ │ ├── UnusedStateVariables.sol
│ │ │ ├── UsingSelfdestruct.sol
│ │ │ ├── VoidConstructor.sol
│ │ │ ├── WeakRandomness.sol
│ │ │ ├── WrongOrderOfLayout.sol
│ │ │ ├── YulReturn.sol
│ │ │ └── ZeroAddressCheck.sol
│ │ └── test
│ │ └── Counter.t.sol
│ ├── foundry-nft-f23
│ │ ├── .github
│ │ │ └── workflows
│ │ │ └── test.yml
│ │ ├── .gitignore
│ │ ├── foundry.lock
│ │ ├── foundry.toml
│ │ ├── README.md
│ │ ├── remappings.txt
│ │ └── src
│ │ ├── BasicNft.sol
│ │ ├── F1.sol
│ │ ├── F2.sol
│ │ ├── Initializer.sol
│ │ └── inner-core-modules
│ │ └── ICM.sol
│ ├── foundry-nft-f23-icm
│ │ ├── .github
│ │ │ └── workflows
│ │ │ └── test.yml
│ │ ├── .gitignore
│ │ ├── aderyn.toml
│ │ ├── foundry.toml
│ │ ├── README.md
│ │ ├── remappings.txt
│ │ └── src
│ │ ├── BasicNft.sol
│ │ ├── F1.sol
│ │ ├── F2.sol
│ │ ├── Initializer.sol
│ │ └── inner-core-modules
│ │ └── ICM.sol
│ ├── hardhat-js-playground
│ │ ├── .gitignore
│ │ ├── artifacts
│ │ │ ├── build-info
│ │ │ │ └── cee6fe9a9a2f03f7ff10a27ab2746af6.json
│ │ │ └── contracts
│ │ │ ├── Counter.sol
│ │ │ │ ├── Counter.dbg.json
│ │ │ │ └── Counter.json
│ │ │ ├── ExtendedInheritance.sol
│ │ │ │ ├── ExtendedInheritance.dbg.json
│ │ │ │ └── ExtendedInheritance.json
│ │ │ ├── IContractInheritance.sol
│ │ │ │ ├── IContractInheritance.dbg.json
│ │ │ │ └── IContractInheritance.json
│ │ │ ├── InheritanceBase.sol
│ │ │ │ ├── InheritanceBase.dbg.json
│ │ │ │ └── InheritanceBase.json
│ │ │ ├── KeccakContract.sol
│ │ │ │ ├── KeccakContract.dbg.json
│ │ │ │ └── KeccakContract.json
│ │ │ ├── Lock.sol
│ │ │ │ ├── Lock.dbg.json
│ │ │ │ └── Lock.json
│ │ │ └── StateVariables.sol
│ │ │ ├── StateVariables.dbg.json
│ │ │ └── StateVariables.json
│ │ ├── contracts
│ │ │ ├── Counter.sol
│ │ │ ├── ExtendedInheritance.sol
│ │ │ ├── IContractInheritance.sol
│ │ │ ├── InheritanceBase.sol
│ │ │ ├── KeccakContract.sol
│ │ │ ├── Lock.sol
│ │ │ └── StateVariables.sol
│ │ ├── hardhat.config.js
│ │ ├── package.json
│ │ ├── README.md
│ │ ├── scripts
│ │ │ └── deploy.js
│ │ ├── test
│ │ │ └── Lock.js
│ │ └── yarn.lock
│ ├── no-sol-files
│ │ ├── extra
│ │ │ └── HelloAgain.md
│ │ ├── Hello.txt
│ │ └── Hello.yul
│ └── toml
│ ├── nested_project1
│ │ ├── aderyn.toml
│ │ ├── folder1
│ │ │ └── hardhat.config.ts
│ │ ├── folder2
│ │ │ └── hardhat.config.ts
│ │ └── folder3
│ │ └── file.txt
│ └── nested_project2
│ ├── aderyn.toml
│ ├── folder1
│ │ └── foundry.toml
│ └── folder2
│ └── file1.txt
├── tools
│ └── xtask
│ ├── Cargo.toml
│ └── src
│ ├── blesspr.rs
│ ├── cut_release.rs
│ ├── flags.rs
│ ├── main.rs
│ ├── reportgen.rs
│ └── tomlgen.rs
└── typos.toml
```
# Files
--------------------------------------------------------------------------------
/benchmarks/useless-public-function/report/index.html:
--------------------------------------------------------------------------------
```html
1 | <!DOCTYPE html>
2 | <html>
3 |
4 | <head>
5 | <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
6 | <title>useless-public-function - Criterion.rs</title>
7 | <style type="text/css">
8 | body {
9 | font: 14px Helvetica Neue;
10 | text-rendering: optimizelegibility;
11 | }
12 |
13 | .body {
14 | width: 960px;
15 | margin: auto;
16 | }
17 |
18 | th {
19 | font-weight: 200
20 | }
21 |
22 | th,
23 | td {
24 | padding-right: 3px;
25 | padding-bottom: 3px;
26 | }
27 |
28 | a:link {
29 | color: #1F78B4;
30 | text-decoration: none;
31 | }
32 |
33 | th.ci-bound {
34 | opacity: 0.6
35 | }
36 |
37 | td.ci-bound {
38 | opacity: 0.5
39 | }
40 |
41 | .stats {
42 | width: 80%;
43 | margin: auto;
44 | display: flex;
45 | }
46 |
47 | .additional_stats {
48 | flex: 0 0 60%
49 | }
50 |
51 | .additional_plots {
52 | flex: 1
53 | }
54 |
55 | h2 {
56 | font-size: 36px;
57 | font-weight: 300;
58 | }
59 |
60 | h3 {
61 | font-size: 24px;
62 | font-weight: 300;
63 | }
64 |
65 | #footer {
66 | height: 40px;
67 | background: #888;
68 | color: white;
69 | font-size: larger;
70 | font-weight: 300;
71 | }
72 |
73 | #footer a {
74 | color: white;
75 | text-decoration: underline;
76 | }
77 |
78 | #footer p {
79 | text-align: center
80 | }
81 | </style>
82 | </head>
83 |
84 | <body>
85 | <div class="body">
86 | <h2>useless-public-function</h2>
87 | <div class="absolute">
88 | <section class="plots">
89 | <table width="100%">
90 | <tbody>
91 | <tr>
92 | <td>
93 | <a href="pdf.svg">
94 | <img src="pdf_small.svg" alt="PDF of Slope" width="450" height="300" />
95 | </a>
96 | </td>
97 | <td>
98 | <a href="regression.svg">
99 | <img src="regression_small.svg" alt="Regression" width="450" height="300" />
100 | </a>
101 | </td>
102 | </tr>
103 | </tbody>
104 | </table>
105 | </section>
106 | <section class="stats">
107 | <div class="additional_stats">
108 | <h4>Additional Statistics:</h4>
109 | <table>
110 | <thead>
111 | <tr>
112 | <th></th>
113 | <th title="0.95 confidence level" class="ci-bound">Lower bound</th>
114 | <th>Estimate</th>
115 | <th title="0.95 confidence level" class="ci-bound">Upper bound</th>
116 | </tr>
117 | </thead>
118 | <tbody>
119 | <tr>
120 | <td>Slope</td>
121 | <td class="ci-bound">462.50 µs</td>
122 | <td>471.35 µs</td>
123 | <td class="ci-bound">481.94 µs</td>
124 | </tr>
125 | <tr>
126 | <td>R²</td>
127 | <td class="ci-bound">0.4935635</td>
128 | <td>0.5082672</td>
129 | <td class="ci-bound">0.4874770</td>
130 | </tr>
131 | <tr>
132 | <td>Mean</td>
133 | <td class="ci-bound">463.97 µs</td>
134 | <td>469.42 µs</td>
135 | <td class="ci-bound">475.90 µs</td>
136 | </tr>
137 | <tr>
138 | <td title="Standard Deviation">Std. Dev.</td>
139 | <td class="ci-bound">17.940 µs</td>
140 | <td>30.771 µs</td>
141 | <td class="ci-bound">42.545 µs</td>
142 | </tr>
143 | <tr>
144 | <td>Median</td>
145 | <td class="ci-bound">456.65 µs</td>
146 | <td>460.09 µs</td>
147 | <td class="ci-bound">464.73 µs</td>
148 | </tr>
149 | <tr>
150 | <td title="Median Absolute Deviation">MAD</td>
151 | <td class="ci-bound">7.4715 µs</td>
152 | <td>12.023 µs</td>
153 | <td class="ci-bound">15.427 µs</td>
154 | </tr>
155 | </tbody>
156 | </table>
157 | </div>
158 | <div class="additional_plots">
159 | <h4>Additional Plots:</h4>
160 | <ul>
161 |
162 | <li>
163 | <a href="typical.svg">Typical</a>
164 | </li>
165 | <li>
166 | <a href="mean.svg">Mean</a>
167 | </li>
168 | <li>
169 | <a href="SD.svg">Std. Dev.</a>
170 | </li>
171 | <li>
172 | <a href="median.svg">Median</a>
173 | </li>
174 | <li>
175 | <a href="MAD.svg">MAD</a>
176 | </li>
177 | <li>
178 | <a href="slope.svg">Slope</a>
179 | </li>
180 | </ul>
181 | </div>
182 | </section>
183 | <section class="explanation">
184 | <h4>Understanding this report:</h4>
185 | <p>The plot on the left displays the average time per iteration for this benchmark. The shaded region
186 | shows the estimated probability of an iteration taking a certain amount of time, while the line
187 | shows the mean. Click on the plot for a larger view showing the outliers.</p>
188 | <p>The plot on the right shows the linear regression calculated from the measurements. Each point
189 | represents a sample, though here it shows the total time for the sample rather than time per
190 | iteration. The line is the line of best fit for these measurements.</p>
191 | <p>See <a href="https://bheisler.github.io/criterion.rs/book/user_guide/command_line_output.html#additional-statistics">the
192 | documentation</a> for more details on the additional statistics.</p>
193 | </section>
194 | </div>
195 | <section class="plots">
196 | <h3>Change Since Previous Benchmark</h3>
197 | <div class="relative">
198 | <table width="100%">
199 | <tbody>
200 | <tr>
201 | <td>
202 | <a href="both/pdf.svg">
203 | <img src="relative_pdf_small.svg" alt="PDF Comparison" width="450"
204 | height="300" />
205 | </a>
206 | </td>
207 | <td>
208 | <a href="both/regression.svg">
209 | <img src="relative_regression_small.svg" alt="Regression Comparison" width="450"
210 | height="300" />
211 | </a>
212 | </td>
213 | </tr>
214 | </tbody>
215 | </table>
216 | </div>
217 | </section>
218 | <section class="stats">
219 | <div class="additional_stats">
220 | <h4>Additional Statistics:</h4>
221 | <table>
222 | <thead>
223 | <tr>
224 | <th></th>
225 | <th title="0.95 confidence level" class="ci-bound">Lower bound</th>
226 | <th>Estimate</th>
227 | <th title="0.95 confidence level" class="ci-bound">Upper bound</th>
228 | <th></th>
229 | </tr>
230 | </thead>
231 | <tbody>
232 | <tr>
233 | <td>Change in time</td>
234 | <td class="ci-bound">-2.4419%</td>
235 | <td>-0.6269%</td>
236 | <td class="ci-bound">+1.2481%</td>
237 | <td>(p = 0.53 >
238 | 0.05)</td>
239 | </tr>
240 | </tbody>
241 | </table>
242 | No change in performance detected.
243 | </div>
244 | <div class="additional_plots">
245 | <h4>Additional Plots:</h4>
246 | <ul>
247 |
248 | <li>
249 | <a href="change/mean.svg">Change in mean</a>
250 | </li>
251 | <li>
252 | <a href="change/median.svg">Change in median</a>
253 | </li>
254 | <li>
255 | <a href="change/t-test.svg">T-Test</a>
256 | </li>
257 | </ul>
258 | </div>
259 | </section>
260 | <section class="explanation">
261 | <h4>Understanding this report:</h4>
262 | <p>The plot on the left shows the probability of the function taking a certain amount of time. The red
263 | curve represents the saved measurements from the last time this benchmark was run, while the blue curve
264 | shows the measurements from this run. The lines represent the mean time per iteration. Click on the
265 | plot for a larger view.</p>
266 | <p>The plot on the right shows the two regressions. Again, the red line represents the previous measurement
267 | while the blue line shows the current measurement.</p>
268 | <p>See <a href="https://bheisler.github.io/criterion.rs/book/user_guide/command_line_output.html#change">the
269 | documentation</a> for more details on the additional statistics.</p>
270 | </section>
271 | </div>
272 | <div id="footer">
273 | <p>This report was generated by
274 | <a href="https://github.com/bheisler/criterion.rs">Criterion.rs</a>, a statistics-driven benchmarking
275 | library in Rust.</p>
276 | </div>
277 | </body>
278 |
279 | </html>
```
--------------------------------------------------------------------------------
/benchmarks/constants-instead-of-literals/report/index.html:
--------------------------------------------------------------------------------
```html
1 | <!DOCTYPE html>
2 | <html>
3 |
4 | <head>
5 | <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
6 | <title>constants-instead-of-literals - Criterion.rs</title>
7 | <style type="text/css">
8 | body {
9 | font: 14px Helvetica Neue;
10 | text-rendering: optimizelegibility;
11 | }
12 |
13 | .body {
14 | width: 960px;
15 | margin: auto;
16 | }
17 |
18 | th {
19 | font-weight: 200
20 | }
21 |
22 | th,
23 | td {
24 | padding-right: 3px;
25 | padding-bottom: 3px;
26 | }
27 |
28 | a:link {
29 | color: #1F78B4;
30 | text-decoration: none;
31 | }
32 |
33 | th.ci-bound {
34 | opacity: 0.6
35 | }
36 |
37 | td.ci-bound {
38 | opacity: 0.5
39 | }
40 |
41 | .stats {
42 | width: 80%;
43 | margin: auto;
44 | display: flex;
45 | }
46 |
47 | .additional_stats {
48 | flex: 0 0 60%
49 | }
50 |
51 | .additional_plots {
52 | flex: 1
53 | }
54 |
55 | h2 {
56 | font-size: 36px;
57 | font-weight: 300;
58 | }
59 |
60 | h3 {
61 | font-size: 24px;
62 | font-weight: 300;
63 | }
64 |
65 | #footer {
66 | height: 40px;
67 | background: #888;
68 | color: white;
69 | font-size: larger;
70 | font-weight: 300;
71 | }
72 |
73 | #footer a {
74 | color: white;
75 | text-decoration: underline;
76 | }
77 |
78 | #footer p {
79 | text-align: center
80 | }
81 | </style>
82 | </head>
83 |
84 | <body>
85 | <div class="body">
86 | <h2>constants-instead-of-literals</h2>
87 | <div class="absolute">
88 | <section class="plots">
89 | <table width="100%">
90 | <tbody>
91 | <tr>
92 | <td>
93 | <a href="pdf.svg">
94 | <img src="pdf_small.svg" alt="PDF of Slope" width="450" height="300" />
95 | </a>
96 | </td>
97 | <td>
98 | <a href="regression.svg">
99 | <img src="regression_small.svg" alt="Regression" width="450" height="300" />
100 | </a>
101 | </td>
102 | </tr>
103 | </tbody>
104 | </table>
105 | </section>
106 | <section class="stats">
107 | <div class="additional_stats">
108 | <h4>Additional Statistics:</h4>
109 | <table>
110 | <thead>
111 | <tr>
112 | <th></th>
113 | <th title="0.95 confidence level" class="ci-bound">Lower bound</th>
114 | <th>Estimate</th>
115 | <th title="0.95 confidence level" class="ci-bound">Upper bound</th>
116 | </tr>
117 | </thead>
118 | <tbody>
119 | <tr>
120 | <td>Slope</td>
121 | <td class="ci-bound">1.3561 ms</td>
122 | <td>1.3750 ms</td>
123 | <td class="ci-bound">1.3959 ms</td>
124 | </tr>
125 | <tr>
126 | <td>R²</td>
127 | <td class="ci-bound">0.5441818</td>
128 | <td>0.5567445</td>
129 | <td class="ci-bound">0.5414915</td>
130 | </tr>
131 | <tr>
132 | <td>Mean</td>
133 | <td class="ci-bound">1.4019 ms</td>
134 | <td>1.4238 ms</td>
135 | <td class="ci-bound">1.4480 ms</td>
136 | </tr>
137 | <tr>
138 | <td title="Standard Deviation">Std. Dev.</td>
139 | <td class="ci-bound">87.052 µs</td>
140 | <td>118.06 µs</td>
141 | <td class="ci-bound">145.82 µs</td>
142 | </tr>
143 | <tr>
144 | <td>Median</td>
145 | <td class="ci-bound">1.3652 ms</td>
146 | <td>1.3891 ms</td>
147 | <td class="ci-bound">1.4130 ms</td>
148 | </tr>
149 | <tr>
150 | <td title="Median Absolute Deviation">MAD</td>
151 | <td class="ci-bound">49.760 µs</td>
152 | <td>78.706 µs</td>
153 | <td class="ci-bound">101.89 µs</td>
154 | </tr>
155 | </tbody>
156 | </table>
157 | </div>
158 | <div class="additional_plots">
159 | <h4>Additional Plots:</h4>
160 | <ul>
161 |
162 | <li>
163 | <a href="typical.svg">Typical</a>
164 | </li>
165 | <li>
166 | <a href="mean.svg">Mean</a>
167 | </li>
168 | <li>
169 | <a href="SD.svg">Std. Dev.</a>
170 | </li>
171 | <li>
172 | <a href="median.svg">Median</a>
173 | </li>
174 | <li>
175 | <a href="MAD.svg">MAD</a>
176 | </li>
177 | <li>
178 | <a href="slope.svg">Slope</a>
179 | </li>
180 | </ul>
181 | </div>
182 | </section>
183 | <section class="explanation">
184 | <h4>Understanding this report:</h4>
185 | <p>The plot on the left displays the average time per iteration for this benchmark. The shaded region
186 | shows the estimated probability of an iteration taking a certain amount of time, while the line
187 | shows the mean. Click on the plot for a larger view showing the outliers.</p>
188 | <p>The plot on the right shows the linear regression calculated from the measurements. Each point
189 | represents a sample, though here it shows the total time for the sample rather than time per
190 | iteration. The line is the line of best fit for these measurements.</p>
191 | <p>See <a href="https://bheisler.github.io/criterion.rs/book/user_guide/command_line_output.html#additional-statistics">the
192 | documentation</a> for more details on the additional statistics.</p>
193 | </section>
194 | </div>
195 | <section class="plots">
196 | <h3>Change Since Previous Benchmark</h3>
197 | <div class="relative">
198 | <table width="100%">
199 | <tbody>
200 | <tr>
201 | <td>
202 | <a href="both/pdf.svg">
203 | <img src="relative_pdf_small.svg" alt="PDF Comparison" width="450"
204 | height="300" />
205 | </a>
206 | </td>
207 | <td>
208 | <a href="both/regression.svg">
209 | <img src="relative_regression_small.svg" alt="Regression Comparison" width="450"
210 | height="300" />
211 | </a>
212 | </td>
213 | </tr>
214 | </tbody>
215 | </table>
216 | </div>
217 | </section>
218 | <section class="stats">
219 | <div class="additional_stats">
220 | <h4>Additional Statistics:</h4>
221 | <table>
222 | <thead>
223 | <tr>
224 | <th></th>
225 | <th title="0.95 confidence level" class="ci-bound">Lower bound</th>
226 | <th>Estimate</th>
227 | <th title="0.95 confidence level" class="ci-bound">Upper bound</th>
228 | <th></th>
229 | </tr>
230 | </thead>
231 | <tbody>
232 | <tr>
233 | <td>Change in time</td>
234 | <td class="ci-bound">+23.046%</td>
235 | <td>+25.560%</td>
236 | <td class="ci-bound">+28.361%</td>
237 | <td>(p = 0.00 <
238 | 0.05)</td>
239 | </tr>
240 | </tbody>
241 | </table>
242 | Performance has regressed.
243 | </div>
244 | <div class="additional_plots">
245 | <h4>Additional Plots:</h4>
246 | <ul>
247 |
248 | <li>
249 | <a href="change/mean.svg">Change in mean</a>
250 | </li>
251 | <li>
252 | <a href="change/median.svg">Change in median</a>
253 | </li>
254 | <li>
255 | <a href="change/t-test.svg">T-Test</a>
256 | </li>
257 | </ul>
258 | </div>
259 | </section>
260 | <section class="explanation">
261 | <h4>Understanding this report:</h4>
262 | <p>The plot on the left shows the probability of the function taking a certain amount of time. The red
263 | curve represents the saved measurements from the last time this benchmark was run, while the blue curve
264 | shows the measurements from this run. The lines represent the mean time per iteration. Click on the
265 | plot for a larger view.</p>
266 | <p>The plot on the right shows the two regressions. Again, the red line represents the previous measurement
267 | while the blue line shows the current measurement.</p>
268 | <p>See <a href="https://bheisler.github.io/criterion.rs/book/user_guide/command_line_output.html#change">the
269 | documentation</a> for more details on the additional statistics.</p>
270 | </section>
271 | </div>
272 | <div id="footer">
273 | <p>This report was generated by
274 | <a href="https://github.com/bheisler/criterion.rs">Criterion.rs</a>, a statistics-driven benchmarking
275 | library in Rust.</p>
276 | </div>
277 | </body>
278 |
279 | </html>
```
--------------------------------------------------------------------------------
/benchmarks/useless-internal-function/report/index.html:
--------------------------------------------------------------------------------
```html
1 | <!DOCTYPE html>
2 | <html>
3 |
4 | <head>
5 | <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
6 | <title>useless-internal-function - Criterion.rs</title>
7 | <style type="text/css">
8 | body {
9 | font: 14px Helvetica Neue;
10 | text-rendering: optimizelegibility;
11 | }
12 |
13 | .body {
14 | width: 960px;
15 | margin: auto;
16 | }
17 |
18 | th {
19 | font-weight: 200
20 | }
21 |
22 | th,
23 | td {
24 | padding-right: 3px;
25 | padding-bottom: 3px;
26 | }
27 |
28 | a:link {
29 | color: #1F78B4;
30 | text-decoration: none;
31 | }
32 |
33 | th.ci-bound {
34 | opacity: 0.6
35 | }
36 |
37 | td.ci-bound {
38 | opacity: 0.5
39 | }
40 |
41 | .stats {
42 | width: 80%;
43 | margin: auto;
44 | display: flex;
45 | }
46 |
47 | .additional_stats {
48 | flex: 0 0 60%
49 | }
50 |
51 | .additional_plots {
52 | flex: 1
53 | }
54 |
55 | h2 {
56 | font-size: 36px;
57 | font-weight: 300;
58 | }
59 |
60 | h3 {
61 | font-size: 24px;
62 | font-weight: 300;
63 | }
64 |
65 | #footer {
66 | height: 40px;
67 | background: #888;
68 | color: white;
69 | font-size: larger;
70 | font-weight: 300;
71 | }
72 |
73 | #footer a {
74 | color: white;
75 | text-decoration: underline;
76 | }
77 |
78 | #footer p {
79 | text-align: center
80 | }
81 | </style>
82 | </head>
83 |
84 | <body>
85 | <div class="body">
86 | <h2>useless-internal-function</h2>
87 | <div class="absolute">
88 | <section class="plots">
89 | <table width="100%">
90 | <tbody>
91 | <tr>
92 | <td>
93 | <a href="pdf.svg">
94 | <img src="pdf_small.svg" alt="PDF of Slope" width="450" height="300" />
95 | </a>
96 | </td>
97 | <td>
98 | <a href="regression.svg">
99 | <img src="regression_small.svg" alt="Regression" width="450" height="300" />
100 | </a>
101 | </td>
102 | </tr>
103 | </tbody>
104 | </table>
105 | </section>
106 | <section class="stats">
107 | <div class="additional_stats">
108 | <h4>Additional Statistics:</h4>
109 | <table>
110 | <thead>
111 | <tr>
112 | <th></th>
113 | <th title="0.95 confidence level" class="ci-bound">Lower bound</th>
114 | <th>Estimate</th>
115 | <th title="0.95 confidence level" class="ci-bound">Upper bound</th>
116 | </tr>
117 | </thead>
118 | <tbody>
119 | <tr>
120 | <td>Slope</td>
121 | <td class="ci-bound">15.839 µs</td>
122 | <td>16.070 µs</td>
123 | <td class="ci-bound">16.357 µs</td>
124 | </tr>
125 | <tr>
126 | <td>R²</td>
127 | <td class="ci-bound">0.4261988</td>
128 | <td>0.4320976</td>
129 | <td class="ci-bound">0.4230508</td>
130 | </tr>
131 | <tr>
132 | <td>Mean</td>
133 | <td class="ci-bound">16.323 µs</td>
134 | <td>16.765 µs</td>
135 | <td class="ci-bound">17.297 µs</td>
136 | </tr>
137 | <tr>
138 | <td title="Standard Deviation">Std. Dev.</td>
139 | <td class="ci-bound">1.3830 µs</td>
140 | <td>2.5163 µs</td>
141 | <td class="ci-bound">3.5335 µs</td>
142 | </tr>
143 | <tr>
144 | <td>Median</td>
145 | <td class="ci-bound">15.886 µs</td>
146 | <td>16.001 µs</td>
147 | <td class="ci-bound">16.172 µs</td>
148 | </tr>
149 | <tr>
150 | <td title="Median Absolute Deviation">MAD</td>
151 | <td class="ci-bound">413.45 ns</td>
152 | <td>621.21 ns</td>
153 | <td class="ci-bound">851.57 ns</td>
154 | </tr>
155 | </tbody>
156 | </table>
157 | </div>
158 | <div class="additional_plots">
159 | <h4>Additional Plots:</h4>
160 | <ul>
161 |
162 | <li>
163 | <a href="typical.svg">Typical</a>
164 | </li>
165 | <li>
166 | <a href="mean.svg">Mean</a>
167 | </li>
168 | <li>
169 | <a href="SD.svg">Std. Dev.</a>
170 | </li>
171 | <li>
172 | <a href="median.svg">Median</a>
173 | </li>
174 | <li>
175 | <a href="MAD.svg">MAD</a>
176 | </li>
177 | <li>
178 | <a href="slope.svg">Slope</a>
179 | </li>
180 | </ul>
181 | </div>
182 | </section>
183 | <section class="explanation">
184 | <h4>Understanding this report:</h4>
185 | <p>The plot on the left displays the average time per iteration for this benchmark. The shaded region
186 | shows the estimated probability of an iteration taking a certain amount of time, while the line
187 | shows the mean. Click on the plot for a larger view showing the outliers.</p>
188 | <p>The plot on the right shows the linear regression calculated from the measurements. Each point
189 | represents a sample, though here it shows the total time for the sample rather than time per
190 | iteration. The line is the line of best fit for these measurements.</p>
191 | <p>See <a href="https://bheisler.github.io/criterion.rs/book/user_guide/command_line_output.html#additional-statistics">the
192 | documentation</a> for more details on the additional statistics.</p>
193 | </section>
194 | </div>
195 | <section class="plots">
196 | <h3>Change Since Previous Benchmark</h3>
197 | <div class="relative">
198 | <table width="100%">
199 | <tbody>
200 | <tr>
201 | <td>
202 | <a href="both/pdf.svg">
203 | <img src="relative_pdf_small.svg" alt="PDF Comparison" width="450"
204 | height="300" />
205 | </a>
206 | </td>
207 | <td>
208 | <a href="both/regression.svg">
209 | <img src="relative_regression_small.svg" alt="Regression Comparison" width="450"
210 | height="300" />
211 | </a>
212 | </td>
213 | </tr>
214 | </tbody>
215 | </table>
216 | </div>
217 | </section>
218 | <section class="stats">
219 | <div class="additional_stats">
220 | <h4>Additional Statistics:</h4>
221 | <table>
222 | <thead>
223 | <tr>
224 | <th></th>
225 | <th title="0.95 confidence level" class="ci-bound">Lower bound</th>
226 | <th>Estimate</th>
227 | <th title="0.95 confidence level" class="ci-bound">Upper bound</th>
228 | <th></th>
229 | </tr>
230 | </thead>
231 | <tbody>
232 | <tr>
233 | <td>Change in time</td>
234 | <td class="ci-bound">-3.6256%</td>
235 | <td>+1.1376%</td>
236 | <td class="ci-bound">+6.2274%</td>
237 | <td>(p = 0.65 >
238 | 0.05)</td>
239 | </tr>
240 | </tbody>
241 | </table>
242 | No change in performance detected.
243 | </div>
244 | <div class="additional_plots">
245 | <h4>Additional Plots:</h4>
246 | <ul>
247 |
248 | <li>
249 | <a href="change/mean.svg">Change in mean</a>
250 | </li>
251 | <li>
252 | <a href="change/median.svg">Change in median</a>
253 | </li>
254 | <li>
255 | <a href="change/t-test.svg">T-Test</a>
256 | </li>
257 | </ul>
258 | </div>
259 | </section>
260 | <section class="explanation">
261 | <h4>Understanding this report:</h4>
262 | <p>The plot on the left shows the probability of the function taking a certain amount of time. The red
263 | curve represents the saved measurements from the last time this benchmark was run, while the blue curve
264 | shows the measurements from this run. The lines represent the mean time per iteration. Click on the
265 | plot for a larger view.</p>
266 | <p>The plot on the right shows the two regressions. Again, the red line represents the previous measurement
267 | while the blue line shows the current measurement.</p>
268 | <p>See <a href="https://bheisler.github.io/criterion.rs/book/user_guide/command_line_output.html#change">the
269 | documentation</a> for more details on the additional statistics.</p>
270 | </section>
271 | </div>
272 | <div id="footer">
273 | <p>This report was generated by
274 | <a href="https://github.com/bheisler/criterion.rs">Criterion.rs</a>, a statistics-driven benchmarking
275 | library in Rust.</p>
276 | </div>
277 | </body>
278 |
279 | </html>
```
--------------------------------------------------------------------------------
/aderyn_core/src/context/flow/display.rs:
--------------------------------------------------------------------------------
```rust
1 | use crate::context::{browser::Peek, workspace::WorkspaceContext};
2 |
3 | use super::{CfgBreakStatement, CfgNodeDescriptor, primitives::*, voids::*};
4 |
5 | impl CfgNodeDescriptor {
6 | pub fn display(&self, context: &WorkspaceContext) -> String {
7 | match self {
8 | // Voids
9 | CfgNodeDescriptor::Start(n) => n.peek(),
10 | CfgNodeDescriptor::End(n) => n.peek(),
11 |
12 | // Primitives
13 | CfgNodeDescriptor::VariableDeclarationStatement(n) => n.peek(context),
14 | CfgNodeDescriptor::ExpressionStatement(n) => n.peek(context),
15 | CfgNodeDescriptor::PlaceholderStatement(n) => n.peek(),
16 | CfgNodeDescriptor::Break(n) => n.peek(),
17 | CfgNodeDescriptor::Continue(n) => n.peek(),
18 | CfgNodeDescriptor::Return(n) => n.peek(context),
19 | CfgNodeDescriptor::EmitStatement(n) => n.peek(context),
20 | CfgNodeDescriptor::RevertStatement(n) => n.peek(context),
21 | CfgNodeDescriptor::InlineAssembly(n) => n.peek(context),
22 | CfgNodeDescriptor::TryStatement(n) => n.peek(context),
23 | CfgNodeDescriptor::IfStatementCondition(n) => n.peek(context),
24 | CfgNodeDescriptor::WhileStatementCondition(n) => n.peek(context),
25 | CfgNodeDescriptor::ForStatementCondition(n) => n.peek(context),
26 | CfgNodeDescriptor::DoWhileStatementCondition(n) => n.peek(context),
27 |
28 | // Reducibles
29 | CfgNodeDescriptor::IfStatement(_) => String::from("REDUCIBLE IF-STATEMENT"),
30 | CfgNodeDescriptor::WhileStatement(_) => String::from("REDUCIBLE WHILE-STATEMENT"),
31 | CfgNodeDescriptor::DoWhileStatement(_) => String::from("REDUCIBLE DO-WHILE-STATEMENT"),
32 | CfgNodeDescriptor::ForStatement(_) => String::from("REDUCIBLE FOR-STATEMENT"),
33 | CfgNodeDescriptor::Block(_) => String::from("REDUCIBLE BLOCK"),
34 | CfgNodeDescriptor::UncheckedBlock(_) => String::from("REDUCIBLE UNCHECKED BLOCK"),
35 | }
36 | }
37 | }
38 |
39 | impl CfgStartNode {
40 | pub fn peek(&self) -> String {
41 | match self {
42 | CfgStartNode::Start => String::from("START"),
43 | CfgStartNode::StartBlock(ast_id) => format!("START BLOCK ({})", ast_id),
44 | CfgStartNode::StartUncheckedBlock(ast_id) => {
45 | format!("START UNCHECKED BLOCK ({})", ast_id)
46 | }
47 | CfgStartNode::StartModifierBody(ast_id) => {
48 | format!("START MODIFIER BODY {}", ast_id)
49 | }
50 | CfgStartNode::StartFunctionBody(ast_id) => {
51 | format!("START FUNCTION BODY {}", ast_id)
52 | }
53 | CfgStartNode::StartIf(ast_id) => format!("START IF ({})", ast_id),
54 | CfgStartNode::StartIfCond => String::from("START IF COND"),
55 | CfgStartNode::StartIfTrue => String::from("START IF TRUE BRANCH"),
56 | CfgStartNode::StartIfFalse => String::from("START IF FALSE BRANCH"),
57 | CfgStartNode::StartWhile(ast_id) => format!("START WHILE ({})", ast_id),
58 | CfgStartNode::StartWhileCond => String::from("START WHILE COND"),
59 | CfgStartNode::StartWhileBody => String::from("START WHILE BODY"),
60 | CfgStartNode::StartFor(ast_id) => format!("START FOR ({})", ast_id),
61 | CfgStartNode::StartForInitExp => String::from("START FOR INIT_EXP"),
62 | CfgStartNode::StartForCond => String::from("START FOR COND"),
63 | CfgStartNode::StartForLoopExp => String::from("START FOR LOOP_EXP"),
64 | CfgStartNode::StartForBody => String::from("START FOR BODY"),
65 | CfgStartNode::StartDoWhile(ast_id) => format!("START DO WHILE ({})", ast_id),
66 | CfgStartNode::StartDoWhileCond => String::from("START DO WHILE COND"),
67 | CfgStartNode::StartDoWhileBody => String::from("START DO WHILE BODY"),
68 | }
69 | }
70 | }
71 |
72 | impl CfgEndNode {
73 | pub fn peek(&self) -> String {
74 | match self {
75 | CfgEndNode::End => String::from("END"),
76 | CfgEndNode::EndBlock(ast_id) => format!("END BLOCK ({})", ast_id),
77 | CfgEndNode::EndUncheckedBlock(ast_id) => format!("END UNCHECKED BLOCK ({})", ast_id),
78 | CfgEndNode::EndModifierBody(ast_id) => format!("END MODIFIER BODY ({})", ast_id),
79 | CfgEndNode::EndFunctionBody(ast_id) => format!("END FUNCTION BODY ({})", ast_id),
80 | CfgEndNode::EndIf(ast_id) => format!("END IF ({})", ast_id),
81 | CfgEndNode::EndIfCond => String::from("END IF COND"),
82 | CfgEndNode::EndIfTrue => String::from("END IF TRUE BRANCH"),
83 | CfgEndNode::EndIfFalse => String::from("END IF FALSE BRANCH"),
84 | CfgEndNode::EndWhile(ast_id) => format!("END WHILE ({})", ast_id),
85 | CfgEndNode::EndWhileCond => String::from("END WHILE COND"),
86 | CfgEndNode::EndWhileBody => String::from("END WHILE BODY"),
87 | CfgEndNode::EndFor(ast_id) => format!("END FOR ({})", ast_id),
88 | CfgEndNode::EndForInitExp => String::from("END FOR INIT_EXP"),
89 | CfgEndNode::EndForCond => String::from("END FOR COND"),
90 | CfgEndNode::EndForLoopExp => String::from("END FOR LOOP_EXP"),
91 | CfgEndNode::EndForBody => String::from("END FOR BODY"),
92 | CfgEndNode::EndDoWhile(ast_id) => format!("END DO WHILE ({})", ast_id),
93 | CfgEndNode::EndDoWhileCond => String::from("END DO WHILE COND"),
94 | CfgEndNode::EndDoWhileBody => String::from("END DO WHILE BODY"),
95 | }
96 | }
97 | }
98 |
99 | impl CfgVariableDeclarationStatement {
100 | pub fn peek(&self, context: &WorkspaceContext) -> String {
101 | let mut content = format!("Variable Decl. Stmt ({})", self.variable_declaration_statement);
102 | if let Some(node) = context.nodes.get(&self.variable_declaration_statement)
103 | && let Some(inside) = node.peek(context)
104 | {
105 | content.push_str(&format!(": \n{}", inside));
106 | }
107 | content
108 | }
109 | }
110 |
111 | impl CfgExpressionStatement {
112 | pub fn peek(&self, context: &WorkspaceContext) -> String {
113 | let mut content = format!("Expression Stmt ({})", self.expression_statement);
114 | if let Some(node) = context.nodes.get(&self.expression_statement)
115 | && let Some(inside) = node.peek(context)
116 | {
117 | content.push_str(&format!(": \n{}", inside));
118 | }
119 | content
120 | }
121 | }
122 |
123 | impl CfgBreakStatement {
124 | pub fn peek(&self) -> String {
125 | format!("BREAK ({})", &self.break_statement)
126 | }
127 | }
128 |
129 | impl CfgContinueStatement {
130 | pub fn peek(&self) -> String {
131 | format!("CONTINUE ({})", &self.continue_statement)
132 | }
133 | }
134 |
135 | impl CfgReturnStatement {
136 | pub fn peek(&self, context: &WorkspaceContext) -> String {
137 | let mut content = format!("Return Stmt ({})", self.return_statement);
138 | if let Some(node) = context.nodes.get(&self.return_statement)
139 | && let Some(inside) = node.peek(context)
140 | {
141 | content.push_str(&format!(": \n{}", inside));
142 | }
143 | content
144 | }
145 | }
146 |
147 | impl CfgEmitStatement {
148 | pub fn peek(&self, context: &WorkspaceContext) -> String {
149 | let mut content = format!("Emit Stmt ({})", self.emit_statement);
150 | if let Some(node) = context.nodes.get(&self.emit_statement)
151 | && let Some(inside) = node.peek(context)
152 | {
153 | content.push_str(&format!(": \n{}", inside));
154 | }
155 | content
156 | }
157 | }
158 |
159 | impl CfgRevertStatement {
160 | pub fn peek(&self, context: &WorkspaceContext) -> String {
161 | let mut content = format!("Revert Stmt ({})", self.revert_statement);
162 | if let Some(node) = context.nodes.get(&self.revert_statement)
163 | && let Some(inside) = node.peek(context)
164 | {
165 | content.push_str(&format!(": \n{}", inside));
166 | }
167 | content
168 | }
169 | }
170 |
171 | impl CfgInlineAssemblyStatement {
172 | pub fn peek(&self, context: &WorkspaceContext) -> String {
173 | let mut content = format!("Inline Assembly Stmt ({})", self.inline_assembly_statement);
174 | if let Some(node) = context.nodes.get(&self.inline_assembly_statement)
175 | && let Some(inside) = node.peek(context)
176 | {
177 | content.push_str(&format!(": \n{}", inside));
178 | }
179 | content
180 | }
181 | }
182 |
183 | impl CfgPlaceholderStatement {
184 | pub fn peek(&self) -> String {
185 | let mut content = format!("Placeholder statement ({})", self.placeholder_statement);
186 | content.push_str(": \n_");
187 | content
188 | }
189 | }
190 |
191 | impl CfgIfStatementCondition {
192 | pub fn peek(&self, context: &WorkspaceContext) -> String {
193 | let Some(if_cond) = self.if_stmt_condition else {
194 | return String::from("If Cond");
195 | };
196 | let mut content = format!("If Cond ({})", if_cond);
197 | if let Some(node) = context.nodes.get(&if_cond)
198 | && let Some(inside) = node.peek(context)
199 | {
200 | content.push_str(&format!(": \n{}", inside));
201 | }
202 | content
203 | }
204 | }
205 |
206 | impl CfgWhileStatementCondition {
207 | pub fn peek(&self, context: &WorkspaceContext) -> String {
208 | let Some(while_cond) = self.while_stmt_condition else {
209 | return String::from("While Cond");
210 | };
211 | let mut content = format!("While Cond ({})", while_cond);
212 | if let Some(node) = context.nodes.get(&while_cond)
213 | && let Some(inside) = node.peek(context)
214 | {
215 | content.push_str(&format!(": \n{}", inside));
216 | }
217 | content
218 | }
219 | }
220 |
221 | impl CfgForStatementCondition {
222 | pub fn peek(&self, context: &WorkspaceContext) -> String {
223 | let Some(for_stmt) = self.for_stmt_condition else {
224 | return String::from("For Cond");
225 | };
226 | let mut content = format!("For Cond ({})", for_stmt);
227 | if let Some(node) = context.nodes.get(&for_stmt)
228 | && let Some(inside) = node.peek(context)
229 | {
230 | content.push_str(&format!(": \n{}", inside));
231 | }
232 | content
233 | }
234 | }
235 |
236 | impl CfgDoWhileStatementCondition {
237 | pub fn peek(&self, context: &WorkspaceContext) -> String {
238 | let Some(for_stmt) = self.do_while_stmt_condition else {
239 | return String::from("Do While Cond");
240 | };
241 | let mut content = format!("Do While Cond ({})", for_stmt);
242 | if let Some(node) = context.nodes.get(&for_stmt)
243 | && let Some(inside) = node.peek(context)
244 | {
245 | content.push_str(&format!(": \n{}", inside));
246 | }
247 | content
248 | }
249 | }
250 |
251 | impl CfgTryStatement {
252 | pub fn peek(&self, context: &WorkspaceContext) -> String {
253 | let mut content = format!("Try Stmt ({})", self.try_statement);
254 | if let Some(node) = context.nodes.get(&self.try_statement)
255 | && let Some(inside) = node.peek(context)
256 | {
257 | content.push_str(&format!(": \n{}", inside));
258 | }
259 | content
260 | }
261 | }
262 |
```
--------------------------------------------------------------------------------
/benchmarks/non-reentrant-before-others/report/relative_pdf_small.svg:
--------------------------------------------------------------------------------
```
1 | <svg width="450" height="300" viewBox="0 0 450 300" xmlns="http://www.w3.org/2000/svg">
2 | <text x="15" y="130" dy="0.76em" text-anchor="middle" font-family="sans-serif" font-size="9.67741935483871" opacity="1" fill="#000000" transform="rotate(270, 15, 130)">
3 | Density (a.u.)
4 | </text>
5 | <text x="255" y="285" dy="-0.5ex" text-anchor="middle" font-family="sans-serif" font-size="9.67741935483871" opacity="1" fill="#000000">
6 | Average Time (µs)
7 | </text>
8 | <polyline fill="none" opacity="1" stroke="#000000" stroke-width="1" points="74,15 74,244 "/>
9 | <text x="65" y="198" dy="0.5ex" text-anchor="end" font-family="sans-serif" font-size="9.67741935483871" opacity="1" fill="#000000">
10 | 0.5
11 | </text>
12 | <polyline fill="none" opacity="1" stroke="#000000" stroke-width="1" points="69,198 74,198 "/>
13 | <text x="65" y="151" dy="0.5ex" text-anchor="end" font-family="sans-serif" font-size="9.67741935483871" opacity="1" fill="#000000">
14 | 1
15 | </text>
16 | <polyline fill="none" opacity="1" stroke="#000000" stroke-width="1" points="69,151 74,151 "/>
17 | <text x="65" y="105" dy="0.5ex" text-anchor="end" font-family="sans-serif" font-size="9.67741935483871" opacity="1" fill="#000000">
18 | 1.5
19 | </text>
20 | <polyline fill="none" opacity="1" stroke="#000000" stroke-width="1" points="69,105 74,105 "/>
21 | <text x="65" y="58" dy="0.5ex" text-anchor="end" font-family="sans-serif" font-size="9.67741935483871" opacity="1" fill="#000000">
22 | 2
23 | </text>
24 | <polyline fill="none" opacity="1" stroke="#000000" stroke-width="1" points="69,58 74,58 "/>
25 | <polyline fill="none" opacity="1" stroke="#000000" stroke-width="1" points="75,245 434,245 "/>
26 | <text x="78" y="255" dy="0.76em" text-anchor="middle" font-family="sans-serif" font-size="9.67741935483871" opacity="1" fill="#000000">
27 | 3
28 | </text>
29 | <polyline fill="none" opacity="1" stroke="#000000" stroke-width="1" points="78,245 78,250 "/>
30 | <text x="164" y="255" dy="0.76em" text-anchor="middle" font-family="sans-serif" font-size="9.67741935483871" opacity="1" fill="#000000">
31 | 4
32 | </text>
33 | <polyline fill="none" opacity="1" stroke="#000000" stroke-width="1" points="164,245 164,250 "/>
34 | <text x="250" y="255" dy="0.76em" text-anchor="middle" font-family="sans-serif" font-size="9.67741935483871" opacity="1" fill="#000000">
35 | 5
36 | </text>
37 | <polyline fill="none" opacity="1" stroke="#000000" stroke-width="1" points="250,245 250,250 "/>
38 | <text x="336" y="255" dy="0.76em" text-anchor="middle" font-family="sans-serif" font-size="9.67741935483871" opacity="1" fill="#000000">
39 | 6
40 | </text>
41 | <polyline fill="none" opacity="1" stroke="#000000" stroke-width="1" points="336,245 336,250 "/>
42 | <text x="422" y="255" dy="0.76em" text-anchor="middle" font-family="sans-serif" font-size="9.67741935483871" opacity="1" fill="#000000">
43 | 7
44 | </text>
45 | <polyline fill="none" opacity="1" stroke="#000000" stroke-width="1" points="422,245 422,250 "/>
46 | <polygon opacity="0.5" fill="#E31A1C" points="87,244 88,244 88,244 89,244 90,244 91,244 91,244 92,244 93,244 93,244 94,244 95,243 95,243 96,243 97,243 97,243 98,243 99,242 100,242 100,242 101,242 102,241 102,241 103,241 104,240 104,240 105,239 106,239 106,238 107,237 108,237 109,236 109,235 110,234 111,233 111,232 112,231 113,230 113,229 114,228 115,226 116,225 116,224 117,222 118,220 118,219 119,217 120,215 120,213 121,211 122,209 122,207 123,205 124,202 125,200 125,198 126,195 127,193 127,190 128,188 129,185 129,182 130,180 131,177 131,174 132,172 133,169 134,166 134,163 135,161 136,158 136,156 137,153 138,150 138,148 139,146 140,143 141,141 141,139 142,137 143,135 143,133 144,131 145,129 145,128 146,126 147,125 147,124 148,123 149,122 150,121 150,120 151,120 152,119 152,119 153,119 154,119 154,119 155,119 156,119 156,120 157,120 158,121 159,122 159,123 160,124 161,125 161,126 162,127 163,128 163,130 164,131 165,133 165,134 166,136 167,137 168,139 168,141 169,143 170,144 170,146 171,148 172,150 172,152 173,154 174,156 175,158 175,160 176,162 177,164 177,166 178,167 179,169 179,171 180,173 181,175 181,177 182,179 183,180 184,182 184,184 185,185 186,187 186,189 187,190 188,192 188,193 189,195 190,196 190,198 191,199 192,201 193,202 193,203 194,204 195,206 195,207 196,208 197,209 197,210 198,211 199,212 200,213 200,214 201,215 202,216 202,217 203,218 204,218 204,219 205,220 206,221 206,221 207,222 208,223 209,223 209,224 210,224 211,225 211,225 212,226 213,226 213,227 214,227 215,228 215,228 216,228 217,229 218,229 218,229 219,230 220,230 220,230 221,231 222,231 222,231 223,231 224,231 225,232 225,232 226,232 227,232 227,232 228,233 229,233 229,233 230,233 231,233 231,233 232,233 233,234 234,234 234,234 235,234 236,234 236,234 237,234 238,234 238,234 239,235 240,235 240,235 241,235 242,235 243,235 243,235 244,235 245,235 245,236 246,236 247,236 247,236 248,236 249,236 250,236 250,236 251,237 252,237 252,237 253,237 254,237 254,237 255,237 256,238 256,238 257,238 258,238 259,238 259,238 260,238 261,239 261,239 262,239 263,239 263,239 264,239 265,239 265,239 266,240 267,240 268,240 268,240 269,240 270,240 270,240 271,240 272,240 272,240 273,240 274,241 275,241 275,241 276,241 277,241 277,241 278,241 279,241 279,241 280,241 281,241 281,241 282,241 283,241 284,241 284,241 285,241 286,241 286,241 287,241 288,241 288,241 289,241 290,241 290,241 291,241 292,241 293,241 293,241 294,241 295,241 295,241 296,241 297,241 297,241 298,241 299,242 299,242 300,242 301,242 302,242 302,242 303,242 304,242 304,242 305,242 306,242 306,242 307,242 308,242 309,242 309,242 310,242 311,242 311,242 312,242 313,242 313,242 314,242 315,243 315,243 316,243 317,243 318,243 318,243 319,243 320,243 320,243 321,243 322,243 322,243 323,243 324,243 324,243 325,243 326,244 327,244 327,244 328,244 329,244 329,244 330,244 331,244 331,244 332,244 333,244 334,244 334,244 335,244 336,244 336,244 337,244 338,244 338,244 339,244 340,244 340,244 341,244 342,244 343,244 343,244 344,244 345,244 345,244 346,244 347,244 347,244 348,244 349,244 349,244 350,244 351,244 352,244 352,244 353,244 354,244 354,244 355,244 356,244 356,244 357,244 358,244 359,244 359,244 360,244 361,244 361,244 362,244 363,244 363,244 364,244 365,244 365,244 366,244 367,243 368,243 368,243 369,243 370,243 370,243 371,243 372,243 372,243 373,243 374,243 374,243 375,243 376,243 377,243 377,243 378,243 379,243 379,243 380,243 381,243 381,243 382,243 383,243 384,243 384,243 385,243 386,243 386,243 387,243 388,243 388,243 389,243 390,243 390,243 391,243 392,243 393,243 393,243 394,243 395,243 395,243 396,243 397,243 397,243 398,243 399,243 399,243 400,243 401,243 402,243 402,243 403,243 404,243 404,244 405,244 406,244 406,244 407,244 408,244 409,244 409,244 410,244 411,244 411,244 412,244 413,244 413,244 414,244 415,244 415,244 416,244 417,244 418,244 418,244 419,244 420,244 420,244 421,244 422,244 422,244 423,244 424,244 424,244 425,244 426,244 427,244 427,244 428,244 429,244 429,244 430,244 431,244 431,244 432,244 433,244 434,244 434,244 87,244 "/>
47 | <polygon opacity="0.5" fill="#1F78B4" points="75,244 75,244 75,244 75,244 75,244 76,243 76,243 76,243 76,243 77,243 77,243 77,242 77,242 78,242 78,241 78,241 78,241 79,240 79,240 79,239 79,239 79,238 80,237 80,237 80,236 80,235 81,234 81,233 81,232 81,231 82,230 82,228 82,227 82,225 83,224 83,222 83,220 83,218 83,216 84,214 84,212 84,209 84,207 85,204 85,201 85,198 85,195 86,192 86,189 86,186 86,182 87,179 87,175 87,172 87,168 87,164 88,160 88,156 88,152 88,148 89,144 89,140 89,136 89,132 90,128 90,123 90,119 90,115 91,111 91,107 91,103 91,99 92,96 92,92 92,88 92,85 92,81 93,78 93,75 93,72 93,69 94,66 94,63 94,61 94,58 95,56 95,54 95,52 95,50 96,48 96,46 96,45 96,43 96,42 97,41 97,39 97,38 97,37 98,36 98,36 98,35 98,34 99,33 99,33 99,32 99,32 100,31 100,31 100,30 100,30 100,29 101,28 101,28 101,27 101,27 102,26 102,26 102,25 102,25 103,24 103,23 103,23 103,22 104,22 104,21 104,20 104,20 105,19 105,19 105,18 105,18 105,17 106,17 106,16 106,16 106,16 107,16 107,16 107,15 107,16 108,16 108,16 108,16 108,16 109,17 109,17 109,18 109,19 109,20 110,21 110,22 110,23 110,24 111,25 111,26 111,28 111,29 112,31 112,33 112,34 112,36 113,38 113,40 113,42 113,44 113,46 114,48 114,51 114,53 114,55 115,57 115,60 115,62 115,64 116,67 116,69 116,72 116,74 117,76 117,79 117,81 117,83 117,86 118,88 118,90 118,92 118,94 119,97 119,99 119,101 119,103 120,105 120,107 120,109 120,110 121,112 121,114 121,116 121,117 122,119 122,121 122,122 122,124 122,125 123,127 123,128 123,130 123,131 124,132 124,134 124,135 124,137 125,138 125,139 125,141 125,142 126,144 126,145 126,146 126,148 126,149 127,151 127,152 127,154 127,156 128,157 128,159 128,160 128,162 129,163 129,165 129,167 129,168 130,170 130,172 130,173 130,175 130,177 131,178 131,180 131,182 131,183 132,185 132,187 132,188 132,190 133,192 133,193 133,195 133,196 134,198 134,199 134,201 134,202 135,204 135,205 135,207 135,208 135,209 136,211 136,212 136,213 136,214 137,215 137,217 137,218 137,219 138,220 138,221 138,222 138,223 139,224 139,225 139,226 139,227 139,228 140,229 140,229 140,230 140,231 141,232 141,232 141,233 141,234 142,234 142,235 142,235 142,236 143,237 143,237 143,238 143,238 143,238 144,239 144,239 144,240 144,240 145,240 145,241 145,241 145,241 146,241 146,242 146,242 146,242 147,242 147,242 147,243 147,243 148,243 148,243 148,243 148,243 148,243 149,244 149,244 149,244 149,244 150,244 150,244 150,244 150,244 151,244 151,244 151,244 151,244 152,244 152,244 152,244 152,244 152,244 153,244 153,244 153,244 153,244 154,244 154,244 154,244 154,244 155,244 155,244 155,244 155,244 156,244 156,244 156,244 156,244 156,244 157,244 157,244 157,244 157,244 158,244 158,244 158,244 158,244 159,244 159,244 159,244 159,244 160,244 160,244 160,244 160,244 160,244 161,244 161,244 161,244 161,244 162,244 162,244 162,244 162,244 163,244 163,244 163,244 163,244 164,244 164,244 164,244 164,244 165,244 165,244 165,244 165,243 165,243 166,243 166,243 166,243 166,243 167,243 167,243 167,243 167,243 168,242 168,242 168,242 168,242 169,242 169,242 169,242 169,241 169,241 170,241 170,241 170,241 170,241 171,241 171,240 171,240 171,240 172,240 172,240 172,240 172,240 173,240 173,239 173,239 173,239 173,239 174,239 174,239 174,239 174,239 175,239 175,239 175,239 175,239 176,239 176,239 176,239 176,239 177,239 177,239 177,239 177,239 178,239 178,239 178,239 178,239 178,240 179,240 179,240 179,240 179,240 180,240 180,240 180,240 180,241 181,241 181,241 181,241 181,241 182,241 182,241 182,242 182,242 182,242 183,242 183,242 183,242 183,242 184,243 184,243 184,243 184,243 185,243 185,243 185,243 185,243 186,243 186,243 186,244 186,244 186,244 187,244 187,244 187,244 187,244 188,244 188,244 188,244 188,244 189,244 189,244 189,244 189,244 190,244 190,244 190,244 190,244 190,244 191,244 191,244 191,244 191,244 192,244 192,244 192,244 192,244 192,244 75,244 "/>
48 | <polyline fill="none" opacity="1" stroke="#E31A1C" stroke-width="2" points="169,245 169,142 "/>
49 | <polyline fill="none" opacity="1" stroke="#1F78B4" stroke-width="2" points="109,245 109,17 "/>
50 | </svg>
51 |
```
--------------------------------------------------------------------------------
/aderyn_core/src/detect/helpers.rs:
--------------------------------------------------------------------------------
```rust
1 | use semver::{Error, VersionReq};
2 |
3 | use crate::{
4 | ast::{
5 | ASTNode, Expression, FunctionDefinition, Identifier, LiteralKind, MemberAccess, NodeID,
6 | PragmaDirective, Visibility,
7 | },
8 | context::{
9 | browser::{
10 | ExtractBinaryOperations, ExtractFunctionCallOptions, ExtractFunctionCalls,
11 | ExtractMemberAccesses,
12 | },
13 | workspace::WorkspaceContext,
14 | },
15 | };
16 |
17 | /// Count the number of identifiers that reference a given ID in the context.
18 | pub fn count_identifiers_that_reference_an_id(
19 | context: &WorkspaceContext,
20 | function_id: NodeID,
21 | ) -> i32 {
22 | let mut count = 0;
23 | context.identifiers().iter().for_each(|&identifier| {
24 | if let Some(reference_id) = identifier.referenced_declaration
25 | && reference_id == function_id
26 | {
27 | count += 1;
28 | }
29 | });
30 | count
31 | }
32 |
33 | pub fn get_calls_and_delegate_calls(context: &WorkspaceContext) -> Vec<&MemberAccess> {
34 | context
35 | .member_accesses()
36 | .into_iter()
37 | .filter(|member_access| {
38 | member_access.member_name == "call" || member_access.member_name == "delegatecall"
39 | })
40 | .collect()
41 | }
42 |
43 | // Get all implemented external and public functions in the context.
44 | pub fn get_implemented_external_and_public_functions(
45 | context: &WorkspaceContext,
46 | ) -> impl Iterator<Item = &FunctionDefinition> {
47 | context.function_definitions().into_iter().filter(|function| {
48 | (function.visibility == Visibility::Public || function.visibility == Visibility::External)
49 | && function.implemented
50 | })
51 | }
52 |
53 | pub fn pragma_directive_to_semver(pragma_directive: &PragmaDirective) -> Result<VersionReq, Error> {
54 | let mut version_string = String::new();
55 |
56 | for literal in &pragma_directive.literals {
57 | if literal == "solidity" {
58 | continue;
59 | }
60 | if version_string.is_empty() && literal.contains("0.") {
61 | version_string.push('=');
62 | }
63 | if version_string.len() > 5 && (literal == "<" || literal == "=") {
64 | version_string.push(',');
65 | }
66 | version_string.push_str(literal);
67 | }
68 | VersionReq::parse(&version_string)
69 | }
70 |
71 | // Check if an ast_node has a `msg.sender` binary operation.
72 | // Examples:
73 | // ```
74 | // function foo() public {
75 | // require(msg.sender == owner);
76 | // }
77 | // ```
78 | pub fn has_msg_sender_binary_operation(ast_node: &ASTNode) -> bool {
79 | // Directly return the evaluation of the condition
80 | ExtractBinaryOperations::from(ast_node).extracted.iter().any(|binary_operation| {
81 | ExtractMemberAccesses::from(binary_operation).extracted.iter().any(|member_access| {
82 | member_access.member_name == "sender"
83 | && if let Expression::Identifier(identifier) = member_access.expression.as_ref() {
84 | identifier.name == "msg"
85 | } else {
86 | false
87 | }
88 | })
89 | })
90 | }
91 |
92 | // Check if an ast_node sends native eth
93 | // Examples:
94 | // ```
95 | // function foo() public {
96 | // address(0x1).call{value: 10}("...")
97 | // }
98 | // ```
99 | pub fn has_calls_that_sends_native_eth(ast_node: &ASTNode) -> bool {
100 | // Check for address(..).call{value: 10}("...") pattern
101 | let function_call_ops = ExtractFunctionCallOptions::from(ast_node).extracted;
102 | for function_call in &function_call_ops {
103 | let call_carries_value = function_call.names.contains(&String::from("value"));
104 | if !call_carries_value {
105 | continue;
106 | }
107 | if let Expression::MemberAccess(member_access) = function_call.expression.as_ref() {
108 | let is_call = member_access.member_name == "call";
109 | if !is_call {
110 | continue;
111 | }
112 | }
113 | return true;
114 | }
115 |
116 | // Now, check for :-
117 |
118 | // payable(address(..)).transfer(100)
119 | // payable(address(..)).send(100)
120 | // address.sendValue(..) (from openzeppelin)
121 |
122 | let function_calls = ExtractFunctionCalls::from(ast_node).extracted;
123 |
124 | for function_call in function_calls {
125 | if let Expression::MemberAccess(member_access) = function_call.expression.as_ref()
126 | && (member_access.member_name == "transfer"
127 | || member_access.member_name == "send"
128 | || member_access.member_name == "sendValue")
129 | && let Some(type_description) = member_access.expression.type_descriptions()
130 | && type_description
131 | .type_string
132 | .as_ref()
133 | .is_some_and(|type_string| type_string.starts_with("address"))
134 | {
135 | return true;
136 | }
137 | }
138 |
139 | false
140 | }
141 |
142 | /// Detects for the pattern
143 | /// x.delegatecall("...") where x is not a state variable
144 | /// That means, it can be
145 | /// a) An Identifier that references a variable declaration which is not `state_variable`
146 | /// b) A literal address
147 | pub fn has_delegate_calls_on_non_state_variables(
148 | ast_node: &ASTNode,
149 | context: &WorkspaceContext,
150 | ) -> bool {
151 | let member_accesses = ExtractMemberAccesses::from(ast_node).extracted;
152 | member_accesses.into_iter().any(|member| {
153 | let is_delegate_call = member.member_name == "delegatecall";
154 | let mut is_on_non_state_variable = false;
155 | if let Expression::Identifier(identifier) = member.expression.as_ref() {
156 | if let Some(referenced_id) = identifier.referenced_declaration
157 | && let Some(ASTNode::VariableDeclaration(v)) = context.nodes.get(&referenced_id)
158 | && !v.state_variable
159 | {
160 | is_on_non_state_variable = true;
161 | }
162 | } else if let Expression::Literal(_) = member.expression.as_ref() {
163 | is_on_non_state_variable = true;
164 | }
165 | is_delegate_call && is_on_non_state_variable
166 | })
167 | }
168 |
169 | /// Detects for the pattern
170 | /// x.call("...") where x is not a state variable
171 | /// That means, it can be
172 | /// a) An Identifier that references a variable declaration which is not `state_variable`
173 | /// b) A literal address
174 | pub fn get_low_level_calls_on_non_state_variable_addresses(
175 | ast_node: &ASTNode,
176 | context: &WorkspaceContext,
177 | ) -> Vec<MemberAccess> {
178 | ExtractMemberAccesses::from(ast_node)
179 | .extracted
180 | .into_iter()
181 | .filter_map(|member| {
182 | if member.member_name != "call" {
183 | return None;
184 | }
185 | if let Expression::Identifier(identifier) = member.expression.as_ref() {
186 | if let Some(referenced_id) = identifier.referenced_declaration
187 | && let Some(ASTNode::VariableDeclaration(v)) = context.nodes.get(&referenced_id)
188 | && !v.state_variable
189 | {
190 | return Some(member);
191 | }
192 | } else if let Expression::Literal(_) = member.expression.as_ref() {
193 | return Some(member);
194 | }
195 | None
196 | })
197 | .collect::<_>()
198 | }
199 |
200 | pub fn has_binary_checks_on_some_address(ast_node: &ASTNode) -> bool {
201 | let binary_operations = ExtractBinaryOperations::from(ast_node).extracted;
202 | binary_operations.into_iter().any(|op| {
203 | [op.left_expression, op.right_expression].iter().any(|op| {
204 | op.as_ref().type_descriptions().is_some_and(|desc| {
205 | desc.type_string.as_ref().is_some_and(|type_string| {
206 | type_string == "address" || type_string == "address payable"
207 | })
208 | })
209 | })
210 | })
211 | }
212 |
213 | pub fn get_literal_value_or_constant_variable_value(
214 | node_id: NodeID,
215 | context: &WorkspaceContext,
216 | ) -> Option<String> {
217 | match context.nodes.get(&node_id)? {
218 | ASTNode::Literal(literal) => return literal.value.to_owned(),
219 | ASTNode::VariableDeclaration(variable) => {
220 | if variable.mutability() == Some(&crate::ast::Mutability::Constant)
221 | && let Some(Expression::Literal(literal)) = variable.value.as_ref()
222 | {
223 | return literal.value.to_owned();
224 | }
225 | }
226 | _ => (),
227 | }
228 | None
229 | }
230 |
231 | pub fn get_node_offset(node: &ASTNode) -> Option<usize> {
232 | let src_location = node.src()?;
233 |
234 | let chopped_location = match src_location.rfind(':') {
235 | Some(index) => &src_location[..index],
236 | None => src_location, // No colon found, return the original string
237 | }
238 | .to_string();
239 |
240 | let (offset, _) = chopped_location.split_once(':').unwrap();
241 | offset.parse::<usize>().ok()
242 | }
243 |
244 | /*
245 | Check if expression in constant
246 | Expression::Literal whose value is false/true
247 | Expression::Identifier that refers to a constant boolean variable declaration
248 | Expression::UnaryOperation with ! operator followed by a sub expression that could be either of the above
249 | */
250 | pub fn is_constant_boolean(context: &WorkspaceContext, ast_node: &Expression) -> bool {
251 | if let Expression::Literal(literal) = ast_node
252 | && literal.kind == LiteralKind::Bool
253 | && literal.value.as_ref().is_some_and(|value| value == "false" || value == "true")
254 | {
255 | return true;
256 | }
257 | if let Expression::Identifier(Identifier { referenced_declaration: Some(id), .. }) = ast_node
258 | && let Some(ASTNode::VariableDeclaration(variable_declaration)) = context.nodes.get(id)
259 | && variable_declaration
260 | .type_descriptions
261 | .type_string
262 | .as_ref()
263 | .is_some_and(|value| value == "bool")
264 | && variable_declaration.mutability() == Some(&crate::ast::Mutability::Constant)
265 | {
266 | return true;
267 | }
268 | if let Expression::UnaryOperation(operation) = ast_node
269 | && operation.operator == "!"
270 | {
271 | return is_constant_boolean(context, operation.sub_expression.as_ref());
272 | }
273 | false
274 | }
275 |
276 | /// List of [`ASTNode`]s that are in some kind of a loop
277 | /// Typically used as starting points to explore inward from callgraph
278 | pub fn get_explore_centers_of_loops(context: &WorkspaceContext) -> Vec<&ASTNode> {
279 | let mut explore_node_ids: Vec<Option<NodeID>> = vec![];
280 |
281 | for for_loop in context.for_statements() {
282 | if let Some(loop_expression) = for_loop.loop_expression.as_ref() {
283 | explore_node_ids.push(loop_expression.expression.get_node_id());
284 | }
285 | if let Some(condition) = &for_loop.condition {
286 | explore_node_ids.push(condition.get_node_id());
287 | }
288 | explore_node_ids.push(for_loop.body.get_node_id());
289 | }
290 |
291 | for while_loop in context.while_statements() {
292 | explore_node_ids.push(while_loop.condition.get_node_id());
293 | explore_node_ids.push(while_loop.body.get_node_id());
294 | }
295 |
296 | for do_while_loop in context.do_while_statements() {
297 | explore_node_ids.push(do_while_loop.condition.get_node_id());
298 | explore_node_ids.push(Some(do_while_loop.body.id));
299 | }
300 |
301 | let mut explore_nodes = Vec::with_capacity(explore_node_ids.len());
302 |
303 | for id in explore_node_ids.iter().flatten() {
304 | if let Some(ast_node) = context.nodes.get(id) {
305 | explore_nodes.push(ast_node);
306 | }
307 | }
308 |
309 | explore_nodes
310 | }
311 |
```
--------------------------------------------------------------------------------
/aderyn_core/src/ast/impls/node/expressions.rs:
--------------------------------------------------------------------------------
```rust
1 | use crate::{ast::*, visitor::ast_visitor::*};
2 | use eyre::Result;
3 |
4 | impl Node for Expression {
5 | fn accept(&self, visitor: &mut impl ASTConstVisitor) -> Result<()> {
6 | match self {
7 | Expression::Literal(literal) => literal.accept(visitor),
8 | Expression::Identifier(identifier) => identifier.accept(visitor),
9 | Expression::UnaryOperation(unary_operation) => unary_operation.accept(visitor),
10 | Expression::BinaryOperation(binary_operation) => binary_operation.accept(visitor),
11 | Expression::Conditional(conditional) => conditional.accept(visitor),
12 | Expression::Assignment(assignment) => assignment.accept(visitor),
13 | Expression::FunctionCall(function_call) => function_call.accept(visitor),
14 | Expression::FunctionCallOptions(function_call_options) => {
15 | function_call_options.accept(visitor)
16 | }
17 | Expression::IndexAccess(index_access) => index_access.accept(visitor),
18 | Expression::IndexRangeAccess(index_range_access) => index_range_access.accept(visitor),
19 | Expression::MemberAccess(member_access) => member_access.accept(visitor),
20 | Expression::ElementaryTypeNameExpression(elementary_type_name_expression) => {
21 | elementary_type_name_expression.accept(visitor)
22 | }
23 | Expression::TupleExpression(tuple_expression) => tuple_expression.accept(visitor),
24 | Expression::NewExpression(new_expression) => new_expression.accept(visitor),
25 | }
26 | }
27 |
28 | fn accept_id(&self, visitor: &mut impl ASTConstVisitor) -> Result<()> {
29 | visitor.visit_node_id(self.get_node_id())?;
30 | Ok(())
31 | }
32 | }
33 |
34 | impl Node for UnaryOperation {
35 | fn accept(&self, visitor: &mut impl ASTConstVisitor) -> Result<()> {
36 | if visitor.visit_unary_operation(self)? {
37 | self.sub_expression.accept(visitor)?
38 | }
39 | self.accept_metadata(visitor)?;
40 | visitor.end_visit_unary_operation(self)
41 | }
42 | fn accept_metadata(&self, visitor: &mut impl ASTConstVisitor) -> Result<()> {
43 | if let Some(child_id) = self.sub_expression.get_node_id() {
44 | visitor.visit_immediate_children(self.id, vec![child_id])?;
45 | }
46 | Ok(())
47 | }
48 | macros::accept_id!();
49 | }
50 |
51 | impl Node for BinaryOperation {
52 | fn accept(&self, visitor: &mut impl ASTConstVisitor) -> Result<()> {
53 | if visitor.visit_binary_operation(self)? {
54 | self.left_expression.accept(visitor)?;
55 | self.right_expression.accept(visitor)?;
56 | }
57 | self.accept_metadata(visitor)?;
58 | visitor.end_visit_binary_operation(self)
59 | }
60 | fn accept_metadata(&self, visitor: &mut impl ASTConstVisitor) -> Result<()> {
61 | if let Some(left_node_id) = self.left_expression.get_node_id() {
62 | visitor.visit_immediate_children(self.id, vec![left_node_id])?;
63 | }
64 | if let Some(right_node) = self.right_expression.get_node_id() {
65 | visitor.visit_immediate_children(self.id, vec![right_node])?;
66 | }
67 | Ok(())
68 | }
69 | macros::accept_id!();
70 | }
71 |
72 | impl Node for Conditional {
73 | fn accept(&self, visitor: &mut impl ASTConstVisitor) -> Result<()> {
74 | if visitor.visit_conditional(self)? {
75 | self.condition.accept(visitor)?;
76 | self.true_expression.accept(visitor)?;
77 | self.false_expression.accept(visitor)?;
78 | }
79 | self.accept_metadata(visitor)?;
80 | visitor.end_visit_conditional(self)
81 | }
82 | fn accept_metadata(&self, visitor: &mut impl ASTConstVisitor) -> Result<()> {
83 | if let Some(condition_id) = self.condition.get_node_id() {
84 | visitor.visit_immediate_children(self.id, vec![condition_id])?;
85 | }
86 | if let Some(true_expression_id) = self.true_expression.get_node_id() {
87 | visitor.visit_immediate_children(self.id, vec![true_expression_id])?;
88 | }
89 | if let Some(false_expression_id) = self.false_expression.get_node_id() {
90 | visitor.visit_immediate_children(self.id, vec![false_expression_id])?;
91 | }
92 | Ok(())
93 | }
94 | macros::accept_id!();
95 | }
96 |
97 | impl Node for Assignment {
98 | fn accept(&self, visitor: &mut impl ASTConstVisitor) -> Result<()> {
99 | if visitor.visit_assignment(self)? {
100 | self.left_hand_side.accept(visitor)?;
101 | self.right_hand_side.accept(visitor)?;
102 | }
103 | self.accept_metadata(visitor)?;
104 | visitor.end_visit_assignment(self)
105 | }
106 | fn accept_metadata(&self, visitor: &mut impl ASTConstVisitor) -> Result<()> {
107 | if let Some(left_hand_id) = self.left_hand_side.get_node_id() {
108 | visitor.visit_immediate_children(self.id, vec![left_hand_id])?;
109 | }
110 | if let Some(right_hand_id) = self.right_hand_side.get_node_id() {
111 | visitor.visit_immediate_children(self.id, vec![right_hand_id])?;
112 | }
113 | Ok(())
114 | }
115 | macros::accept_id!();
116 | }
117 |
118 | impl Node for FunctionCall {
119 | fn accept(&self, visitor: &mut impl ASTConstVisitor) -> Result<()> {
120 | if visitor.visit_function_call(self)? {
121 | self.expression.accept(visitor)?;
122 | list_accept(&self.arguments, visitor)?;
123 | }
124 | self.accept_metadata(visitor)?;
125 | visitor.end_visit_function_call(self)
126 | }
127 | fn accept_metadata(&self, visitor: &mut impl ASTConstVisitor) -> Result<()> {
128 | if let Some(expr_id) = self.expression.get_node_id() {
129 | visitor.visit_immediate_children(self.id, vec![expr_id])?;
130 | }
131 | let mut argument_ids = vec![];
132 | for arg in &self.arguments {
133 | if let Some(arg_id) = arg.get_node_id() {
134 | argument_ids.push(arg_id);
135 | }
136 | }
137 | visitor.visit_immediate_children(self.id, argument_ids)?;
138 | Ok(())
139 | }
140 | macros::accept_id!();
141 | }
142 |
143 | impl Node for FunctionCallOptions {
144 | fn accept(&self, visitor: &mut impl ASTConstVisitor) -> Result<()> {
145 | if visitor.visit_function_call_options(self)? {
146 | self.expression.accept(visitor)?;
147 | if self.arguments.is_some() {
148 | list_accept(self.arguments.as_ref().unwrap(), visitor)?;
149 | }
150 | }
151 | self.accept_metadata(visitor)?;
152 | visitor.end_visit_function_call_options(self)
153 | }
154 | fn accept_metadata(&self, visitor: &mut impl ASTConstVisitor) -> Result<()> {
155 | if let Some(expr_id) = self.expression.get_node_id() {
156 | visitor.visit_immediate_children(self.id, vec![expr_id])?;
157 | }
158 | let mut argument_ids = vec![];
159 | if let Some(arguments) = &self.arguments {
160 | for arg in arguments {
161 | if let Some(arg_id) = arg.get_node_id() {
162 | argument_ids.push(arg_id);
163 | }
164 | }
165 | visitor.visit_immediate_children(self.id, argument_ids)?;
166 | }
167 | Ok(())
168 | }
169 | macros::accept_id!();
170 | }
171 |
172 | impl Node for IndexAccess {
173 | fn accept(&self, visitor: &mut impl ASTConstVisitor) -> Result<()> {
174 | if visitor.visit_index_access(self)? {
175 | self.base_expression.accept(visitor)?;
176 | if let Some(index_expression) = &self.index_expression {
177 | index_expression.accept(visitor)?;
178 | }
179 | }
180 | self.accept_metadata(visitor)?;
181 | visitor.end_visit_index_access(self)
182 | }
183 | fn accept_metadata(&self, visitor: &mut impl ASTConstVisitor) -> Result<()> {
184 | if let Some(base_expr_id) = self.base_expression.get_node_id() {
185 | visitor.visit_immediate_children(self.id, vec![base_expr_id])?;
186 | }
187 | if let Some(index_expression) = &self.index_expression
188 | && let Some(index_expr_id) = index_expression.get_node_id()
189 | {
190 | visitor.visit_immediate_children(self.id, vec![index_expr_id])?;
191 | }
192 | Ok(())
193 | }
194 | macros::accept_id!();
195 | }
196 |
197 | impl Node for IndexRangeAccess {
198 | fn accept(&self, visitor: &mut impl ASTConstVisitor) -> Result<()> {
199 | if visitor.visit_index_range_access(self)? {
200 | self.base_expression.accept(visitor)?;
201 | if self.start_expression.is_some() {
202 | self.start_expression.as_ref().unwrap().accept(visitor)?;
203 | }
204 | if self.end_expression.is_some() {
205 | self.end_expression.as_ref().unwrap().accept(visitor)?;
206 | }
207 | }
208 | self.accept_metadata(visitor)?;
209 | visitor.end_visit_index_range_access(self)
210 | }
211 | fn accept_metadata(&self, visitor: &mut impl ASTConstVisitor) -> Result<()> {
212 | if let Some(start_expression) = &self.start_expression
213 | && let Some(start_expr_id) = start_expression.get_node_id()
214 | {
215 | visitor.visit_immediate_children(self.id, vec![start_expr_id])?;
216 | }
217 | if let Some(end_expression) = &self.end_expression
218 | && let Some(end_expr_id) = end_expression.get_node_id()
219 | {
220 | visitor.visit_immediate_children(self.id, vec![end_expr_id])?;
221 | }
222 | Ok(())
223 | }
224 | macros::accept_id!();
225 | }
226 |
227 | impl Node for MemberAccess {
228 | fn accept(&self, visitor: &mut impl ASTConstVisitor) -> Result<()> {
229 | if visitor.visit_member_access(self)? {
230 | self.expression.accept(visitor)?;
231 | }
232 | self.accept_metadata(visitor)?;
233 | visitor.end_visit_member_access(self)
234 | }
235 | fn accept_metadata(&self, visitor: &mut impl ASTConstVisitor) -> Result<()> {
236 | if let Some(expr_id) = self.expression.get_node_id() {
237 | visitor.visit_immediate_children(self.id, vec![expr_id])?;
238 | }
239 | Ok(())
240 | }
241 | macros::accept_id!();
242 | }
243 |
244 | impl Node for ElementaryTypeNameExpression {
245 | fn accept(&self, visitor: &mut impl ASTConstVisitor) -> Result<()> {
246 | visitor.visit_elementary_type_name_expression(self)?;
247 | visitor.end_visit_elementary_type_name_expression(self)
248 | }
249 | macros::accept_id!();
250 | }
251 |
252 | impl Node for TupleExpression {
253 | fn accept(&self, visitor: &mut impl ASTConstVisitor) -> Result<()> {
254 | if visitor.visit_tuple_expression(self)? {
255 | for elem in &self.components {
256 | if elem.is_some() {
257 | elem.as_ref().unwrap().accept(visitor)?;
258 | }
259 | }
260 | }
261 | self.accept_metadata(visitor)?;
262 | visitor.end_visit_tuple_expression(self)
263 | }
264 | fn accept_metadata(&self, visitor: &mut impl ASTConstVisitor) -> Result<()> {
265 | let mut comp_ids = vec![];
266 | for expr in self.components.iter().flatten() {
267 | if let Some(id) = expr.get_node_id() {
268 | comp_ids.push(id)
269 | }
270 | }
271 | visitor.visit_immediate_children(self.id, comp_ids)?;
272 | Ok(())
273 | }
274 | macros::accept_id!();
275 | }
276 |
277 | impl Node for NewExpression {
278 | fn accept(&self, visitor: &mut impl ASTConstVisitor) -> Result<()> {
279 | if visitor.visit_new_expression(self)? {
280 | self.type_name.accept(visitor)?;
281 | }
282 | visitor.end_visit_new_expression(self)
283 | }
284 | macros::accept_id!();
285 | }
286 |
```
--------------------------------------------------------------------------------
/aderyn_core/src/ast/yul.rs:
--------------------------------------------------------------------------------
```rust
1 | // Original source: https://github.com/camden-smallwood/solidity-rs
2 | use crate::visitor::ast_visitor::{ASTConstVisitor, Node, list_accept};
3 | use eyre::Result;
4 | use serde::{Deserialize, Serialize};
5 | use std::{
6 | collections::HashMap,
7 | hash::{Hash, Hasher},
8 | };
9 |
10 | use super::*;
11 |
12 | #[derive(Clone, Debug, Deserialize, Eq, Serialize, PartialEq)]
13 | #[serde(untagged)]
14 | pub enum ExternalReference {
15 | Untagged(ExternalReferenceData),
16 | Tagged(HashMap<String, ExternalReferenceData>),
17 | }
18 |
19 | impl Hash for ExternalReference {
20 | fn hash<H: Hasher>(&self, state: &mut H) {
21 | match self {
22 | ExternalReference::Untagged(data) => {
23 | 0.hash(state); // A unique value to denote the Untagged variant
24 | data.hash(state);
25 | }
26 | ExternalReference::Tagged(map) => {
27 | 1.hash(state); // A unique value to denote the Tagged variant
28 |
29 | // Create a vector of references to the map's key-value pairs
30 | let mut pairs: Vec<_> = map.iter().collect();
31 |
32 | // Sort the vector by keys
33 | pairs.sort_by(|a, b| a.0.cmp(b.0));
34 |
35 | // Hash each pair in the sorted order
36 | for (key, value) in pairs {
37 | key.hash(state);
38 | value.hash(state);
39 | }
40 | }
41 | }
42 | }
43 | }
44 |
45 | #[derive(Clone, Debug, Deserialize, Eq, Serialize, PartialEq, Hash)]
46 | #[serde(rename_all = "camelCase")]
47 | pub struct ExternalReferenceData {
48 | declaration: NodeID,
49 | is_offset: bool,
50 | is_slot: bool,
51 | src: String,
52 | value_size: NodeID,
53 | }
54 |
55 | #[derive(Clone, Debug, Eq, Serialize, Deserialize, PartialEq, Hash)]
56 | #[serde(tag = "nodeType")]
57 | pub enum YulExpression {
58 | YulLiteral(YulLiteral),
59 | YulIdentifier(YulIdentifier),
60 | YulFunctionCall(YulFunctionCall),
61 | }
62 |
63 | impl Node for YulExpression {
64 | fn accept(&self, visitor: &mut impl ASTConstVisitor) -> Result<()> {
65 | match self {
66 | YulExpression::YulLiteral(node) => node.accept(visitor),
67 | YulExpression::YulIdentifier(node) => node.accept(visitor),
68 | YulExpression::YulFunctionCall(node) => node.accept(visitor),
69 | }
70 | }
71 | }
72 |
73 | #[derive(Clone, Debug, Deserialize, Eq, Serialize, PartialEq, Hash)]
74 | #[serde(rename_all = "camelCase")]
75 | pub struct YulLiteral {
76 | pub src: String,
77 | pub kind: YulLiteralKind,
78 | pub value: Option<String>,
79 | pub hex_value: Option<String>,
80 | }
81 |
82 | impl Node for YulLiteral {
83 | fn accept(&self, visitor: &mut impl ASTConstVisitor) -> Result<()> {
84 | visitor.visit_yul_literal(self)?;
85 | visitor.end_visit_yul_literal(self)
86 | }
87 | }
88 |
89 | #[derive(Clone, Debug, Deserialize, Eq, Serialize, PartialEq, Hash)]
90 | #[serde(rename_all = "camelCase")]
91 | pub enum YulLiteralKind {
92 | Bool,
93 | Number,
94 | String,
95 | HexString,
96 | Address,
97 | }
98 |
99 | #[derive(Clone, Debug, Deserialize, Eq, Serialize, PartialEq, Hash)]
100 | #[serde(rename_all = "camelCase")]
101 | pub struct YulIdentifier {
102 | pub name: String,
103 | pub src: String,
104 | }
105 |
106 | impl Node for YulIdentifier {
107 | fn accept(&self, visitor: &mut impl ASTConstVisitor) -> Result<()> {
108 | visitor.visit_yul_identifier(self)?;
109 | visitor.end_visit_yul_identifier(self)
110 | }
111 | }
112 |
113 | #[derive(Clone, Debug, Deserialize, Eq, Serialize, PartialEq, Hash)]
114 | #[serde(rename_all = "camelCase")]
115 | pub struct YulFunctionCall {
116 | pub src: String,
117 | pub function_name: YulIdentifier,
118 | pub arguments: Vec<YulExpression>,
119 | }
120 |
121 | impl Node for YulFunctionCall {
122 | fn accept(&self, visitor: &mut impl ASTConstVisitor) -> Result<()> {
123 | if visitor.visit_yul_function_call(self)? {
124 | self.function_name.accept(visitor)?;
125 | list_accept(&self.arguments, visitor)?;
126 | }
127 | visitor.end_visit_yul_function_call(self)
128 | }
129 | }
130 |
131 | #[derive(Clone, Debug, Deserialize, Eq, Serialize, PartialEq, Hash)]
132 | #[serde(rename_all = "camelCase")]
133 | pub struct YulBlock {
134 | pub statements: Vec<YulStatement>,
135 | }
136 |
137 | impl Node for YulBlock {
138 | fn accept(&self, visitor: &mut impl ASTConstVisitor) -> Result<()> {
139 | if visitor.visit_yul_block(self)? {
140 | list_accept(&self.statements, visitor)?;
141 | }
142 | visitor.end_visit_yul_block(self)
143 | }
144 | }
145 |
146 | #[derive(Clone, Debug, Eq, Serialize, Deserialize, PartialEq, Hash)]
147 | #[serde(tag = "nodeType")]
148 | pub enum YulStatement {
149 | YulIf(YulIf),
150 | YulSwitch(YulSwitch),
151 | YulForLoop(YulForLoop),
152 | YulAssignment(YulAssignment),
153 | YulVariableDeclaration(YulVariableDeclaration),
154 | YulExpressionStatement(YulExpressionStatement),
155 | YulFunctionDefinition(YulFunctionDefinition),
156 | YulBlock(YulBlock),
157 | YulLeave,
158 | YulBreak,
159 | YulContinue,
160 | }
161 |
162 | impl Node for YulStatement {
163 | fn accept(&self, visitor: &mut impl ASTConstVisitor) -> Result<()> {
164 | match self {
165 | YulStatement::YulIf(node) => node.accept(visitor),
166 | YulStatement::YulSwitch(node) => node.accept(visitor),
167 | YulStatement::YulForLoop(node) => node.accept(visitor),
168 | YulStatement::YulAssignment(node) => node.accept(visitor),
169 | YulStatement::YulVariableDeclaration(node) => node.accept(visitor),
170 | YulStatement::YulExpressionStatement(node) => node.accept(visitor),
171 | YulStatement::YulFunctionDefinition(node) => node.accept(visitor),
172 | YulStatement::YulBlock(node) => node.accept(visitor),
173 | YulStatement::YulLeave => Ok(()),
174 | YulStatement::YulBreak => Ok(()),
175 | YulStatement::YulContinue => Ok(()),
176 | }
177 | }
178 | }
179 |
180 | #[derive(Clone, Debug, Deserialize, Eq, Serialize, PartialEq, Hash)]
181 | #[serde(rename_all = "camelCase")]
182 | pub struct YulIf {
183 | pub condition: YulExpression,
184 | pub body: YulBlock,
185 | }
186 |
187 | impl Node for YulIf {
188 | fn accept(&self, visitor: &mut impl ASTConstVisitor) -> Result<()> {
189 | if visitor.visit_yul_if(self)? {
190 | self.condition.accept(visitor)?;
191 | self.body.accept(visitor)?;
192 | }
193 | visitor.end_visit_yul_if(self)
194 | }
195 | }
196 |
197 | #[derive(Clone, Debug, Deserialize, Eq, Serialize, PartialEq, Hash)]
198 | #[serde(rename_all = "camelCase")]
199 | pub struct YulSwitch {
200 | pub cases: Vec<YulCase>,
201 | pub expression: YulExpression,
202 | }
203 |
204 | impl Node for YulSwitch {
205 | fn accept(&self, visitor: &mut impl ASTConstVisitor) -> Result<()> {
206 | if visitor.visit_yul_switch(self)? {
207 | self.expression.accept(visitor)?;
208 | list_accept(&self.cases, visitor)?;
209 | }
210 | visitor.end_visit_yul_switch(self)
211 | }
212 | }
213 |
214 | #[derive(Clone, Debug, Eq, Serialize, PartialEq, Hash)]
215 | #[serde(rename_all = "camelCase")]
216 | pub struct YulCase {
217 | pub body: YulBlock,
218 | pub value: Option<YulExpression>,
219 | }
220 |
221 | impl Node for YulCase {
222 | fn accept(&self, visitor: &mut impl ASTConstVisitor) -> Result<()> {
223 | if visitor.visit_yul_case(self)? {
224 | self.body.accept(visitor)?;
225 | if let Some(value) = &self.value {
226 | value.accept(visitor)?;
227 | }
228 | }
229 | visitor.end_visit_yul_case(self)
230 | }
231 | }
232 |
233 | impl<'de> Deserialize<'de> for YulCase {
234 | fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
235 | let json = serde_json::Value::deserialize(deserializer)?;
236 | let body = json.get("body").unwrap();
237 | let value = json.get("value").unwrap();
238 |
239 | Ok(YulCase {
240 | body: serde_json::from_value(body.clone()).unwrap(),
241 | value: if matches!(value.as_str(), Some("default")) {
242 | None
243 | } else {
244 | Some(serde_json::from_value(value.clone()).unwrap())
245 | },
246 | })
247 | }
248 | }
249 |
250 | #[derive(Clone, Debug, Deserialize, Eq, Serialize, PartialEq, Hash)]
251 | #[serde(rename_all = "camelCase")]
252 | pub struct YulForLoop {
253 | pub pre: YulBlock,
254 | pub condition: YulExpression,
255 | pub post: YulBlock,
256 | pub body: YulBlock,
257 | }
258 |
259 | impl Node for YulForLoop {
260 | fn accept(&self, visitor: &mut impl ASTConstVisitor) -> Result<()> {
261 | if visitor.visit_yul_for_loop(self)? {
262 | self.pre.accept(visitor)?;
263 | self.condition.accept(visitor)?;
264 | self.post.accept(visitor)?;
265 | self.body.accept(visitor)?;
266 | }
267 | visitor.end_visit_yul_for_loop(self)
268 | }
269 | }
270 |
271 | #[derive(Clone, Debug, Deserialize, Eq, Serialize, PartialEq, Hash)]
272 | #[serde(rename_all = "camelCase")]
273 | pub struct YulAssignment {
274 | pub value: YulExpression,
275 | pub variable_names: Vec<YulIdentifier>,
276 | }
277 |
278 | impl Node for YulAssignment {
279 | fn accept(&self, visitor: &mut impl ASTConstVisitor) -> Result<()> {
280 | if visitor.visit_yul_assignment(self)? {
281 | self.value.accept(visitor)?;
282 | list_accept(&self.variable_names, visitor)?;
283 | }
284 | visitor.end_visit_yul_assignment(self)
285 | }
286 | }
287 |
288 | #[derive(Clone, Debug, Deserialize, Eq, Serialize, PartialEq, Hash)]
289 | #[serde(rename_all = "camelCase")]
290 | pub struct YulVariableDeclaration {
291 | pub value: Option<YulExpression>,
292 | pub variables: Vec<YulTypedName>,
293 | }
294 |
295 | impl Node for YulVariableDeclaration {
296 | fn accept(&self, visitor: &mut impl ASTConstVisitor) -> Result<()> {
297 | if visitor.visit_yul_variable_declaration(self)? {
298 | if let Some(value) = &self.value {
299 | value.accept(visitor)?;
300 | }
301 | list_accept(&self.variables, visitor)?;
302 | }
303 | visitor.end_visit_yul_variable_declaration(self)
304 | }
305 | }
306 |
307 | #[derive(Clone, Debug, Deserialize, Eq, Serialize, PartialEq, Hash)]
308 | #[serde(rename_all = "camelCase")]
309 | pub struct YulTypedName {
310 | pub r#type: String,
311 | pub name: String,
312 | }
313 |
314 | impl Node for YulTypedName {
315 | fn accept(&self, visitor: &mut impl ASTConstVisitor) -> Result<()> {
316 | visitor.visit_yul_typed_name(self)?;
317 | visitor.end_visit_yul_typed_name(self)
318 | }
319 | }
320 |
321 | #[derive(Clone, Debug, Deserialize, Eq, Serialize, PartialEq, Hash)]
322 | #[serde(rename_all = "camelCase")]
323 | pub struct YulExpressionStatement {
324 | pub expression: YulExpression,
325 | }
326 |
327 | impl Node for YulExpressionStatement {
328 | fn accept(&self, visitor: &mut impl ASTConstVisitor) -> Result<()> {
329 | if visitor.visit_yul_expression_statement(self)? {
330 | self.expression.accept(visitor)?;
331 | }
332 | visitor.end_visit_yul_expression_statement(self)
333 | }
334 | }
335 |
336 | #[derive(Clone, Debug, Deserialize, Eq, Serialize, PartialEq, Hash)]
337 | #[serde(rename_all = "camelCase")]
338 | pub struct YulFunctionDefinition {
339 | pub name: String,
340 | pub parameters: Option<Vec<YulTypedName>>,
341 | pub return_parameters: Option<Vec<YulTypedName>>,
342 | pub body: YulBlock,
343 | }
344 |
345 | impl Node for YulFunctionDefinition {
346 | fn accept(&self, visitor: &mut impl ASTConstVisitor) -> Result<()> {
347 | if visitor.visit_yul_function_definition(self)? {
348 | if let Some(parameters) = &self.parameters {
349 | list_accept(parameters, visitor)?;
350 | }
351 | if let Some(return_parameters) = &self.return_parameters {
352 | list_accept(return_parameters, visitor)?;
353 | }
354 | self.body.accept(visitor)?;
355 | }
356 | visitor.end_visit_yul_function_definition(self)
357 | }
358 | }
359 |
```
--------------------------------------------------------------------------------
/benchmarks/unsafe-oz-erc721-mint/report/relative_pdf_small.svg:
--------------------------------------------------------------------------------
```
1 | <svg width="450" height="300" viewBox="0 0 450 300" xmlns="http://www.w3.org/2000/svg">
2 | <text x="15" y="130" dy="0.76em" text-anchor="middle" font-family="sans-serif" font-size="9.67741935483871" opacity="1" fill="#000000" transform="rotate(270, 15, 130)">
3 | Density (a.u.)
4 | </text>
5 | <text x="255" y="285" dy="-0.5ex" text-anchor="middle" font-family="sans-serif" font-size="9.67741935483871" opacity="1" fill="#000000">
6 | Average Time (µs)
7 | </text>
8 | <polyline fill="none" opacity="1" stroke="#000000" stroke-width="1" points="74,15 74,244 "/>
9 | <text x="65" y="214" dy="0.5ex" text-anchor="end" font-family="sans-serif" font-size="9.67741935483871" opacity="1" fill="#000000">
10 | 0.005
11 | </text>
12 | <polyline fill="none" opacity="1" stroke="#000000" stroke-width="1" points="69,214 74,214 "/>
13 | <text x="65" y="183" dy="0.5ex" text-anchor="end" font-family="sans-serif" font-size="9.67741935483871" opacity="1" fill="#000000">
14 | 0.01
15 | </text>
16 | <polyline fill="none" opacity="1" stroke="#000000" stroke-width="1" points="69,183 74,183 "/>
17 | <text x="65" y="153" dy="0.5ex" text-anchor="end" font-family="sans-serif" font-size="9.67741935483871" opacity="1" fill="#000000">
18 | 0.015
19 | </text>
20 | <polyline fill="none" opacity="1" stroke="#000000" stroke-width="1" points="69,153 74,153 "/>
21 | <text x="65" y="122" dy="0.5ex" text-anchor="end" font-family="sans-serif" font-size="9.67741935483871" opacity="1" fill="#000000">
22 | 0.02
23 | </text>
24 | <polyline fill="none" opacity="1" stroke="#000000" stroke-width="1" points="69,122 74,122 "/>
25 | <text x="65" y="92" dy="0.5ex" text-anchor="end" font-family="sans-serif" font-size="9.67741935483871" opacity="1" fill="#000000">
26 | 0.025
27 | </text>
28 | <polyline fill="none" opacity="1" stroke="#000000" stroke-width="1" points="69,92 74,92 "/>
29 | <text x="65" y="61" dy="0.5ex" text-anchor="end" font-family="sans-serif" font-size="9.67741935483871" opacity="1" fill="#000000">
30 | 0.03
31 | </text>
32 | <polyline fill="none" opacity="1" stroke="#000000" stroke-width="1" points="69,61 74,61 "/>
33 | <text x="65" y="31" dy="0.5ex" text-anchor="end" font-family="sans-serif" font-size="9.67741935483871" opacity="1" fill="#000000">
34 | 0.035
35 | </text>
36 | <polyline fill="none" opacity="1" stroke="#000000" stroke-width="1" points="69,31 74,31 "/>
37 | <polyline fill="none" opacity="1" stroke="#000000" stroke-width="1" points="75,245 434,245 "/>
38 | <text x="159" y="255" dy="0.76em" text-anchor="middle" font-family="sans-serif" font-size="9.67741935483871" opacity="1" fill="#000000">
39 | 250
40 | </text>
41 | <polyline fill="none" opacity="1" stroke="#000000" stroke-width="1" points="159,245 159,250 "/>
42 | <text x="268" y="255" dy="0.76em" text-anchor="middle" font-family="sans-serif" font-size="9.67741935483871" opacity="1" fill="#000000">
43 | 300
44 | </text>
45 | <polyline fill="none" opacity="1" stroke="#000000" stroke-width="1" points="268,245 268,250 "/>
46 | <text x="377" y="255" dy="0.76em" text-anchor="middle" font-family="sans-serif" font-size="9.67741935483871" opacity="1" fill="#000000">
47 | 350
48 | </text>
49 | <polyline fill="none" opacity="1" stroke="#000000" stroke-width="1" points="377,245 377,250 "/>
50 | <polygon opacity="0.5" fill="#E31A1C" points="75,244 75,244 76,244 76,244 77,244 78,244 78,244 79,244 80,244 80,244 81,244 81,244 82,244 83,244 83,244 84,243 85,243 85,243 86,243 87,243 87,242 88,242 88,242 89,241 90,241 90,241 91,240 92,240 92,239 93,238 93,238 94,237 95,236 95,235 96,234 97,233 97,232 98,231 99,230 99,228 100,227 100,225 101,224 102,222 102,220 103,218 104,217 104,214 105,212 105,210 106,208 107,205 107,203 108,200 109,197 109,195 110,192 111,189 111,186 112,183 112,180 113,176 114,173 114,170 115,167 116,163 116,160 117,156 117,153 118,150 119,146 119,143 120,139 121,136 121,132 122,129 123,125 123,121 124,118 124,114 125,111 126,107 126,104 127,100 128,97 128,93 129,90 129,86 130,83 131,79 131,76 132,72 133,69 133,65 134,62 135,59 135,56 136,52 136,49 137,46 138,43 138,41 139,38 140,35 140,33 141,30 141,28 142,26 143,24 143,22 144,21 145,19 145,18 146,17 147,17 147,16 148,16 148,15 149,16 150,16 150,16 151,17 152,18 152,19 153,20 153,22 154,23 155,25 155,27 156,29 157,31 157,33 158,35 159,38 159,40 160,43 160,46 161,48 162,51 162,54 163,57 164,60 164,63 165,66 165,69 166,72 167,76 167,79 168,82 169,86 169,89 170,92 171,96 171,99 172,103 172,106 173,110 174,113 174,117 175,121 176,124 176,128 177,131 177,135 178,139 179,142 179,146 180,149 181,153 181,156 182,160 183,163 183,167 184,170 184,173 185,176 186,179 186,182 187,185 188,187 188,190 189,192 189,195 190,197 191,199 191,201 192,203 193,205 193,207 194,209 195,210 195,212 196,213 196,215 197,216 198,217 198,218 199,219 200,220 200,221 201,222 202,223 202,224 203,225 203,226 204,226 205,227 205,228 206,228 207,229 207,229 208,230 208,231 209,231 210,232 210,232 211,233 212,233 212,234 213,234 214,235 214,235 215,236 215,236 216,236 217,237 217,237 218,238 219,238 219,238 220,239 220,239 221,239 222,240 222,240 223,240 224,241 224,241 225,241 226,241 226,242 227,242 227,242 228,242 229,242 229,243 230,243 231,243 231,243 232,243 232,243 233,243 234,244 234,244 235,244 236,244 236,244 237,244 238,244 238,244 239,244 239,244 240,244 241,244 241,244 242,244 243,244 243,244 244,244 244,244 245,244 246,244 246,244 247,244 248,244 248,244 249,244 250,244 250,244 251,244 251,244 252,244 253,244 253,244 254,244 255,244 255,244 256,244 256,244 257,244 258,244 258,244 259,244 260,244 260,244 261,244 262,244 262,244 263,244 263,244 264,244 265,244 265,244 266,244 267,244 267,244 268,244 268,244 269,244 270,244 270,244 271,244 272,244 272,244 273,244 274,244 274,244 275,244 275,244 276,244 277,244 277,244 278,244 279,244 279,244 280,244 280,244 281,244 282,244 282,244 283,244 284,244 284,244 285,244 286,244 286,244 287,244 287,244 288,244 289,244 289,244 290,244 291,244 291,244 292,244 292,244 293,244 294,244 294,244 295,244 296,244 296,244 297,244 298,244 298,244 299,244 299,244 300,244 301,244 301,244 302,244 303,244 303,244 304,244 304,244 305,244 306,244 306,244 307,244 308,244 308,244 309,244 310,244 310,244 311,244 311,244 312,244 313,244 313,244 314,244 315,244 315,244 316,244 316,244 317,244 318,244 318,244 319,244 320,244 320,244 321,244 322,244 322,244 323,244 323,244 324,244 325,244 325,244 326,244 327,244 327,244 328,244 328,244 329,244 330,244 330,244 331,244 332,244 332,244 333,244 334,243 334,243 335,243 335,243 336,243 337,243 337,243 338,243 339,243 339,242 340,242 341,242 341,242 342,242 342,242 343,242 344,241 344,241 345,241 346,241 346,241 347,241 347,241 348,241 349,240 349,240 350,240 351,240 351,240 352,240 353,240 353,240 354,240 354,240 355,240 356,240 356,240 357,240 358,240 358,240 359,240 359,241 360,241 361,241 361,241 362,241 363,241 363,241 364,241 365,242 365,242 366,242 366,242 367,242 368,242 368,242 369,243 370,243 370,243 371,243 371,243 372,243 373,243 373,243 374,243 375,244 375,244 376,244 377,244 377,244 378,244 378,244 379,244 380,244 380,244 381,244 382,244 382,244 383,244 383,244 384,244 385,244 385,244 386,244 387,244 387,244 388,244 389,244 389,244 390,244 390,244 75,244 "/>
51 | <polygon opacity="0.5" fill="#1F78B4" points="78,244 78,244 79,244 80,244 81,244 81,244 82,244 83,244 83,244 84,244 85,244 86,244 86,244 87,244 88,244 88,244 89,244 90,244 91,244 91,244 92,244 93,244 93,244 94,244 95,244 96,243 96,243 97,243 98,243 98,243 99,243 100,243 101,243 101,243 102,243 103,243 103,242 104,242 105,242 106,242 106,242 107,242 108,241 108,241 109,241 110,241 111,241 111,240 112,240 113,240 113,240 114,239 115,239 116,239 116,239 117,238 118,238 118,238 119,237 120,237 120,237 121,237 122,236 123,236 123,235 124,235 125,235 125,234 126,234 127,234 128,233 128,233 129,232 130,232 130,232 131,231 132,231 133,230 133,230 134,229 135,229 135,229 136,228 137,228 138,227 138,227 139,226 140,226 140,225 141,225 142,225 143,224 143,224 144,223 145,223 145,223 146,222 147,222 148,221 148,221 149,221 150,220 150,220 151,220 152,219 153,219 153,219 154,218 155,218 155,218 156,217 157,217 158,217 158,217 159,216 160,216 160,216 161,216 162,215 163,215 163,215 164,215 165,214 165,214 166,214 167,214 168,214 168,213 169,213 170,213 170,213 171,213 172,213 173,212 173,212 174,212 175,212 175,212 176,212 177,211 178,211 178,211 179,211 180,211 180,211 181,210 182,210 183,210 183,210 184,210 185,210 185,210 186,209 187,209 188,209 188,209 189,209 190,209 190,209 191,208 192,208 193,208 193,208 194,208 195,208 195,208 196,208 197,207 197,207 198,207 199,207 200,207 200,207 201,207 202,207 202,207 203,207 204,206 205,206 205,206 206,206 207,206 207,206 208,206 209,206 210,206 210,206 211,206 212,206 212,206 213,205 214,205 215,205 215,205 216,205 217,205 217,205 218,205 219,205 220,205 220,205 221,204 222,204 222,204 223,204 224,204 225,204 225,204 226,203 227,203 227,203 228,203 229,203 230,202 230,202 231,202 232,202 232,201 233,201 234,201 235,201 235,200 236,200 237,199 237,199 238,199 239,198 240,198 240,197 241,197 242,197 242,196 243,196 244,195 245,194 245,194 246,193 247,193 247,192 248,192 249,191 250,190 250,190 251,189 252,188 252,187 253,187 254,186 255,185 255,184 256,183 257,183 257,182 258,181 259,180 260,179 260,178 261,177 262,176 262,175 263,174 264,173 265,172 265,171 266,170 267,169 267,168 268,167 269,166 270,164 270,163 271,162 272,161 272,160 273,159 274,157 275,156 275,155 276,154 277,153 277,151 278,150 279,149 279,148 280,147 281,145 282,144 282,143 283,142 284,141 284,140 285,139 286,138 287,137 287,136 288,135 289,134 289,133 290,132 291,131 292,130 292,130 293,129 294,128 294,128 295,127 296,127 297,126 297,126 298,126 299,125 299,125 300,125 301,125 302,125 302,125 303,125 304,125 304,126 305,126 306,127 307,127 307,128 308,128 309,129 309,130 310,131 311,132 312,133 312,134 313,135 314,136 314,137 315,139 316,140 317,141 317,143 318,144 319,146 319,147 320,149 321,151 322,152 322,154 323,156 324,158 324,159 325,161 326,163 327,165 327,167 328,169 329,170 329,172 330,174 331,176 332,178 332,179 333,181 334,183 334,185 335,187 336,188 337,190 337,192 338,193 339,195 339,196 340,198 341,199 342,201 342,202 343,204 344,205 344,206 345,208 346,209 347,210 347,211 348,212 349,214 349,215 350,216 351,217 352,218 352,219 353,219 354,220 354,221 355,222 356,223 356,223 357,224 358,225 359,226 359,226 360,227 361,227 361,228 362,228 363,229 364,230 364,230 365,231 366,231 366,231 367,232 368,232 369,233 369,233 370,233 371,234 371,234 372,234 373,235 374,235 374,235 375,236 376,236 376,236 377,237 378,237 379,237 379,237 380,238 381,238 381,238 382,238 383,239 384,239 384,239 385,239 386,239 386,240 387,240 388,240 389,240 389,240 390,241 391,241 391,241 392,241 393,241 394,241 394,242 395,242 396,242 396,242 397,242 398,242 399,242 399,242 400,243 401,243 401,243 402,243 403,243 404,243 404,243 405,243 406,243 406,243 407,243 408,243 409,244 409,244 410,244 411,244 411,244 412,244 413,244 414,244 414,244 415,244 416,244 416,244 417,244 418,244 419,244 419,244 420,244 421,244 421,244 422,244 423,244 424,244 424,244 425,244 426,244 426,244 427,244 428,244 429,244 429,244 430,244 431,244 431,244 432,244 433,244 434,244 434,244 78,244 "/>
52 | <polyline fill="none" opacity="1" stroke="#E31A1C" stroke-width="2" points="152,244 152,19 "/>
53 | <polyline fill="none" opacity="1" stroke="#1F78B4" stroke-width="2" points="268,244 268,167 "/>
54 | </svg>
55 |
```