.lintrunner.toml

merge_base_with = "main"

[[linter]]
code = 'FLAKE8'
include_patterns = ['**/*.py']
exclude_patterns = [
    'third-party/**',
    '**/third-party/**',
    '.github/scripts/**',
    'exir/serde/**',
    'exir/_serialize/generated/executorch_flatbuffer/**',
    'devtools/bundled_program/serialize/generated/**',
]
command = [
    'python',
    '-m',
    'lintrunner_adapters',
    'run',
    'flake8_linter',
    '--',
    '@{{PATHSFILE}}'
]
init_command = [
    'python',
    '-m',
    'lintrunner_adapters',
    'run',
    'pip_init',
    '--dry-run={{DRYRUN}}',
    '--requirement=requirements-lintrunner.txt',
]

# Black + usort
[[linter]]
code = 'UFMT'
include_patterns = [
    '**/*.py',
    '**/*.pyi',
]
exclude_patterns = [
    'third-party/**',
    '**/third-party/**',
    'exir/serde/**',
    'exir/_serialize/generated/executorch_flatbuffer/**',
    'devtools/bundled_program/serialize/generated/**',
]
command = [
    'python',
    '-m',
    'lintrunner_adapters',
    'run',
    'ufmt_linter',
    '--',
    '@{{PATHSFILE}}'
]
init_command = [
    'python',
    '-m',
    'lintrunner_adapters',
    'run',
    'pip_init',
    '--dry-run={{DRYRUN}}',
    '--no-black-binary',
    '--requirement=requirements-lintrunner.txt',
]
is_formatter = true

#CLANGFORMAT
[[linter]]
code = 'CLANGFORMAT'
include_patterns = [
    '**/*.h',
    '**/*.cpp',
]
exclude_patterns = [
    'third-party/**',
    '**/third-party/**',
    # NB: Objective-C is not supported
    'examples/apple/**',
    'examples/demo-apps/react-native/rnllama/ios/**',
    'extension/apple/**',
    'extension/llm/apple/**',
    # File contains @generated
    'extension/llm/custom_ops/spinquant/fast_hadamard_transform_special.h',
    'extension/llm/custom_ops/spinquant/test/fast_hadamard_transform_special_unstrided_cpu.h',
    # Want to be able to keep c10 in sync with PyTorch core.
    'runtime/core/portable_type/c10/**',
]
command = [
    'python',
    '-m',
    'lintrunner_adapters',
    'run',
    'clangformat_linter',
    '--binary=clang-format',
    '--fallback',
    '--',
    '@{{PATHSFILE}}'
]
init_command = [
    'python',
    '-m',
    'lintrunner_adapters',
    'run',
    'pip_init',
    '--dry-run={{DRYRUN}}',
    '--requirement=requirements-lintrunner.txt',
]
is_formatter = true

[[linter]]
code = 'CPPCHECK'
include_patterns = [
    '**/*.cpp',
    '**/*.h',
    '**/*.hpp',
]
exclude_patterns = [
    # Third-party and vendored code.
    'third-party/**',
    'third_party/**',
    '**/third-party/**',
    '**/third_party/**',

    # Mirrored sources under src/ (Python package layout). Prefer linting canonical paths.
    'src/executorch/**',
    # PyTorch compatibility code kept in sync with upstream.
    'runtime/core/portable_type/c10/**',

    # Generated sources, templates, and codegen tooling to onboard separately.
    'codegen/templates/**',
    'codegen/tools/selective_build.cpp',
    'exir/_serialize/**',

    # Backend-owned code to onboard separately.
    'backends/aoti/**',
    'backends/apple/**',
    'backends/cadence/**',
    'backends/cuda/**',
    'backends/mediatek/**',
    'backends/mlx/**',
    'backends/openvino/**',
    'backends/qualcomm/**',
    'backends/samsung/**',
    'backends/test/**',
    'backends/vulkan/**',
    'backends/webgpu/**',
    'backends/xnnpack/**',

    # Backend-owned examples to onboard with those backends.
    'examples/demo-apps/**',
    'examples/mediatek/**',
    'examples/qualcomm/**',
    'examples/samsung/**',

    # Other examples to onboard separately.
    'examples/devtools/**',
    'examples/llm_manual/**',
    'examples/models/**',
    'examples/portable/**',
    'examples/raspberry_pi/**',

    # EXIR and devtools areas to onboard separately.
    'devtools/bundled_program/**',
    'devtools/etdump/**',
    'exir/backend/test/**',
    'exir/tests/**',
    'exir/verification/**',

    # Extension areas to onboard incrementally.
    'extension/android/**',
    'extension/apple/**',
    'extension/asr/runner/transducer_runner.h',
    'extension/aten_util/**',
    'extension/benchmark/apple/**',
    'extension/cuda/**',
    'extension/data_loader/**',
    'extension/evalue_util/**',
    'extension/flat_tensor/**',
    'extension/kernel_util/make_boxed_from_unboxed_functor.h',
    'extension/kernel_util/test/**',
    'extension/llm/**',
    'extension/memory_allocator/**',
    'extension/module/**',
    'extension/named_data_map/**',
    'extension/pybindings/**',
    'extension/pytree/**',
    'extension/runner_util/**',
    'extension/tensor/**',
    'extension/testing_util/**',
    'extension/threadpool/**',
    'extension/training/**',
    'extension/wasm/**',

    # Kernel areas to onboard separately.
    'kernels/optimized/**',

    # Runtime areas to onboard incrementally.
    'runtime/backend/**',
    'runtime/core/**',
    'runtime/executor/**',
    'runtime/kernel/**',
    'runtime/platform/**',

    # Top-level test and platform integration areas.
    'test/**',
    'zephyr/**',

    # An ExecuTorch platform layer, same as runtime/platform/default above; the
    # et_pal_* functions are called by the runtime, not from this file.
    'examples/arduino/arduino_pal.cpp',
]
command = [
    'python',
    '-m',
    'lintrunner_adapters',
    'run',
    'cppcheck_linter',
    '--enable=warning,style,unusedFunction',
    '--extra-arg=--check-level=exhaustive',
    '--extra-arg=--std=c++17',
    '--extra-arg=--language=c++',
    '--extra-arg=--inline-suppr',
    '--extra-arg=--inconclusive',
    '--extra-arg=--suppress=unusedStructMember',
    '--extra-arg=--suppress=toomanyconfigs',
    '--extra-arg=--suppress=unusedFunction:*.h',
    '--extra-arg=--suppress=unusedFunction:*.hpp',
    # Prim ops use the same ExecuTorch macro idioms as portable kernels.
    '--extra-arg=--suppress=unknownMacro:*kernels/prim_ops/*',
    '--extra-arg=--suppress=syntaxError:*kernels/prim_ops/*',
    '--extra-arg=--suppress=unusedFunction:*kernels/prim_ops/*',
    # Quantized kernels have NEON-gated code and registration helpers that
    # cppcheck cannot see in every configuration.
    '--extra-arg=--suppress=unreadVariable:*kernels/quantized/*',
    '--extra-arg=--suppress=unusedFunction:*kernels/quantized/*',
    '--extra-arg=--suppress=constParameterReference:*kernels/quantized/*',
    '--extra-arg=--suppress=suspiciousFloatingPointCast:*kernels/quantized/*',
    # Kernel tests use fixture helpers, generated-style test cases, and GTest
    # macros that cppcheck cannot consistently resolve as direct use sites.
    '--extra-arg=--suppress=unusedFunction:*kernels/test/*',
    '--extra-arg=--suppress=unreadVariable:*kernels/test/*',
    '--extra-arg=--suppress=unknownMacro:*kernels/test/*',
    '--extra-arg=--suppress=syntaxError:*kernels/test/*',
    '--extra-arg=--suppress=passedByValue:*kernels/test/*',
    '--extra-arg=--suppress=duplicateBranch:*kernels/test/*',
    '--extra-arg=--suppress=useStlAlgorithm:*kernels/test/*',
    '--extra-arg=--suppress=functionStatic:*kernels/test/*',
    # Portable kernels are referenced through generated registration tables,
    # which cppcheck CTU does not see as direct C++ calls.
    '--extra-arg=--suppress=unusedFunction:*kernels/portable/*',
    # Cppcheck does not parse several ExecuTorch macro idioms used heavily in
    # portable kernels, including empty macro arguments and printf-style macros
    # concatenated into string literals.
    '--extra-arg=--suppress=unknownMacro:*kernels/portable/*',
    '--extra-arg=--suppress=syntaxError:*kernels/portable/*',
    # Keep style-only portable-kernel findings scoped to this tree rather than
    # rewriting broad helper code for lint-only advice.
    '--extra-arg=--suppress=useStlAlgorithm:*kernels/portable/*',
    '--extra-arg=--suppress=variableScope:*kernels/portable/*',
    '--extra-arg=--suppress=constParameterReference:*kernels/portable/*',
    '--extra-arg=--suppress=constParameterPointer:*kernels/portable/*',
    '--extra-arg=--suppress=functionStatic:*kernels/portable/*',
    '--extra-arg=--suppress=knownConditionTrueFalse:*kernels/portable/*',
    '--extra-arg=--suppress=invalidFunctionArg:*kernels/portable/*',
    '--',
    '@{{PATHSFILE}}'
]
init_command = [
    'python',
    '-m',
    'lintrunner_adapters',
    'run',
    'pip_init',
    '--dry-run={{DRYRUN}}',
    '--requirement=requirements-lintrunner.txt',
]

[[linter]]
code = 'CMAKE'
include_patterns = [
    "**/*.cmake",
    "**/*.cmake.in",
    "**/CMakeLists.txt",
]
exclude_patterns = [
    'third-party/**',
    '**/third-party/**',
]
command = [
    'python',
    '-m',
    'lintrunner_adapters',
    'run',
    'cmake_linter',
    '--config=.cmakelintrc',
    '--',
    '@{{PATHSFILE}}',
]
init_command = [
    'python',
    '-m',
    'lintrunner_adapters',
    'run',
    'pip_init',
    '--dry-run={{DRYRUN}}',
    '--requirement=requirements-lintrunner.txt',
]

[[linter]]
code = 'CMAKEFORMAT'
include_patterns = [
    "**/*.cmake",
    "**/*.cmake.in",
    "**/CMakeLists.txt",
]
exclude_patterns = [
    'third-party/**',
    '**/third-party/**',
]
command = [
    'python',
    '-m',
    'lintrunner_adapters',
    'run',
    'cmake_format_linter',
    '--',
    '@{{PATHSFILE}}',
]
init_command = [
    'python',
    '-m',
    'lintrunner_adapters',
    'run',
    'pip_init',
    '--dry-run={{DRYRUN}}',
    '--requirement=requirements-lintrunner.txt',
]

[[linter]]
code = 'ETCAPITAL'
include_patterns = [
    '**/*.py',
    '**/*.pyi',
    '**/*.h',
    '**/*.cpp',
    '**/*.md',
    '**/*.rst',
]
exclude_patterns = [
    'third-party/**',
    '**/third-party/**',
]
command = [
    'python',
    '-m',
    'lintrunner_adapters',
    'run',
    'grep_linter',
    # Exclude "ExecuTorch" pattern within URLs
    '--pattern= Executorch(?!\\W*(://|\\.[a-z]{2,}))\\W+',
    '--linter-name=ExecuTorchCapitalization',
    '--error-name=Incorrect capitalization for ExecuTorch',
    """--error-description=
    Please use ExecuTorch with capital T for consistency.
    https://fburl.com/workplace/nsx6hib2
    """,
    '--',
    '@{{PATHSFILE}}',
]

[[linter]]
code = 'NEWLINE'
include_patterns = ['**']
exclude_patterns = [
    'third-party/**',
    '**/third-party/**',
    'shim/**',
    'shim',
    '**/*.png',
    '**/*.webp',
    '**/*.jpeg',
    '**/*.mp3',
    '**/*.mp4',
    '**/*.pte',
    '**/*.pth',
    '**/*.bin',
    '**/*.patch',
    '**/*.svg',
    '**/*.bat',
    '**/*.jpg',
    '**/*.jar',
    '**/*.gif',
    'extension/llm/tokenizers',
    'extension/llm/tokenizers/**',
    'examples/llm_server',
    # muse_glimmer is a symlink to this directory; the linter resolves it and
    # then fails on a directory.
    'examples/models/muse-glimmer',
    # src/executorch/frontends is a symlink to this directory.
    'frontends',
    'backends/cadence/utils/FACTO',
    'examples/cuda',
    'examples/qualcomm',
    'examples/nxp',
    'kernels/portable',
    # File contains @generated
    'extension/llm/custom_ops/spinquant/fast_hadamard_transform_special.h',
    'extension/llm/custom_ops/spinquant/test/fast_hadamard_transform_special_unstrided_cpu.h',
]
command = [
    'python',
    '-m',
    'lintrunner_adapters',
    'run',
    'newlines_linter',
    '--',
    '@{{PATHSFILE}}',
]
is_formatter = true

[[linter]]
code = 'NOSTDINC'
include_patterns = [
    "**/*.c",
    "**/*.cpp",
    "**/*.h",
    "**/*.hpp",
]
exclude_patterns = [
    '**/devtools/**',
    '**/test/**',
    '**/testing_util/**',
    '**/third-party/**',
    'backends/**',
    'devtools/**',
    'examples/**',
    'extension/**',
    'kernels/optimized/**',
    # Justified <functional> include.
    'kernels/portable/cpu/op_bitwise*.cpp',
    'kernels/portable/cpu/op_eq.cpp',
    'kernels/portable/cpu/op_ge.cpp',
    'kernels/portable/cpu/op_gt.cpp',
    'kernels/portable/cpu/op_le.cpp',
    'kernels/portable/cpu/op_lt.cpp',
    'kernels/portable/cpu/op_ne.cpp',
    'runtime/kernel/thread_parallel_interface.h',
    # Zephyr sample application can use std::vector in the sample code
    'zephyr/samples/**',
    'scripts/**',
    '**/.ci/**',
    'third-party/**',
    'util/**',
]
command = [
    'python',
    '-m',
    'lintrunner_adapters',
    'run',
    'grep_linter',
    '--pattern=([^\\S\r\n]*#include\s*<(deque|exception|forward_list|functional|list|map|multimap|multiset|priority_queue|queue|set|stack|string|unordered_map|unordered_multimap|unordered_multiset|unordered_set|vector)>)',
    '--linter-name=NOSTDINC',
    '--error-name=Standard C++ container include in core',
    """--error-description=\
        Standard library containers should not be included in ExecuTorch core \
        because they may call malloc, which is not allowed in core. \
    """,
    '--',
    '@{{PATHSFILE}}',
]

[[linter]]
code = 'NOTORCHINC'
include_patterns = [
    "**/*.c",
    "**/*.cpp",
    "**/*.h",
    "**/*.hpp",
]
exclude_patterns = [
    '**/devtools/**',
    '**/fb/**',
    '**/test/**',
    '**/tests/**',
    '**/testing_util/**',
    '**/third-party/**',
    'backends/**',
    'codegen/templates/RegisterDispatchKeyCustomOps.cpp',
    'codegen/templates/RegisterSchema.cpp',
    'devtools/**',
    'examples/**',
    'exir/verification/bindings.cpp',
    'extension/**',
    # Uses properly-gated (ET_USE_PYTORCH_HEADERS) ATen include.
    'kernels/portable/cpu/util/elementwise_util.h',
    'kernels/portable/cpu/util/math_util.h',
    'kernels/portable/cpu/util/vectorized_math.h',
    'kernels/optimized/**',
    'runtime/core/exec_aten/**',
    # Want to be able to keep c10 in sync with PyTorch core.
    'runtime/core/portable_type/c10/**',
    'runtime/executor/tensor_parser_aten.cpp',
    'scripts/**',
    'test/**',
    'third-party/**',
    'util/**',
]
command = [
    'python',
    '-m',
    'lintrunner_adapters',
    'run',
    'grep_linter',
    '--pattern=#include\s+[<"](aten/|ATen/|torch/)',
    '--linter-name=NOTORCHINC',
    '--error-name=ATen or torch include',
    """--error-description=\
        PyTorch includes in ExecuTorch core are prohibited to prevent \
        accidentally breaking core's requirements; please make sure this \
        header complies (e.g., no streams/malloc/syscalls) and then include \
        a patch to update this linter.\
    """,
    '--',
    '@{{PATHSFILE}}',
]

[[linter]]
code = 'MYPY'
include_patterns = [
    # TODO(https://github.com/pytorch/executorch/issues/7441): Gradually start enabling all folders.
    # 'backends/**/*.py',
    'backends/arm/**/*.py',
    'backends/cortex_m/**/*.py',
    'backends/openvino/**/*.py',
    'build/**/*.py',
    'codegen/**/*.py',
    # 'devtools/**/*.py',
    'devtools/visualization/**/*.py',
    'docs/**/*.py',
    # 'examples/**/*.py',
    'examples/arm/**/*.py',
    'examples/openvino/**/*.py',
    # 'exir/**/*.py',
    # 'extension/**/*.py',
    'kernels/**/*.py',
    'profiler/**/*.py',
    'runtime/**/*.py',
    'scripts/**/*.py',
    'test/**/*.py',
    'util/**/*.py',
    '*.py',
]
exclude_patterns = [
    'third-party/**',
    '**/third-party/**',
    'scripts/check_binary_dependencies.py',
    'profiler/test/test_profiler_e2e.py',
    'backends/arm/test/ops/*.py',
]
command = [
    'python',
    '-m',
    'lintrunner_adapters',
    'run',
    'mypy_linter',
    '--config=.mypy.ini',
    '--show-disable',
    '--',
    '--explicit-package-bases',
    '@{{PATHSFILE}}'
]
init_command = [
    'python',
    '-m',
    'lintrunner_adapters',
    'run',
    'pip_init',
    '--dry-run={{DRYRUN}}',
    '--requirement=requirements-lintrunner.txt',
]

[[linter]]
code = 'BANDIT'
include_patterns = [
    'backends/arm/**/*.py',
    'examples/arm/**/*.py',
    'backends/cortex_m/**/*.py',
]
exclude_patterns = [
    'third-party/**',
    '**/third-party/**',
]
command = [
    'python',
    '-m',
    'lintrunner_adapters',
    'run',
    'bandit_linter',
    '--configfile',
    '.bandit.yaml',
    '--',
    '@{{PATHSFILE}}',
]
init_command = [
    'python',
    '-m',
    'lintrunner_adapters',
    'run',
    'pip_init',
    '--dry-run={{DRYRUN}}',
    '--requirement=requirements-lintrunner.txt',
]

[[linter]]
code = 'LICENSELINT'
include_patterns = [
    '**/*',
]
exclude_patterns = [
    '**/fb/**',
    '.lintrunner.toml',
]
command = [
    'python',
    '-m',
    'lintrunner_adapters',
    'run',
    'grep_linter',
    '--pattern=Confidential and proprietary',
    '--linter-name=LICENSELINT',
    '--error-name=Wrong license',
    """--error-description=\
        Code contributed to ExecuTorch open source repo should have \
        BSD-license header \
    """,
    '--',
    '@{{PATHSFILE}}',
]

[[linter]]
code = "TORCH_AO_IMPORT"
include_patterns = ["**/*.py"]
exclude_patterns = [
    "third-party/**",
    # TODO: remove exceptions as we migrate
    # backends
    "exir/tests/test_memory_planning.py",
    "exir/backend/test/demos/test_xnnpack_qnnpack.py",
    "backends/xnnpack/test/test_xnnpack_utils.py",
]

command = [
  "python",
  "-m",
  "lintrunner_adapters",
  "run",
  "grep_linter",
  "--pattern=\\bfrom torch\\.ao\\.quantization\\.(?:quantizer|observer|quantize_pt2e|pt2e)(?:\\.[A-Za-z0-9_]+)*\\b",
  "--linter-name=TorchAOImport",
  "--error-name=Prohibited torch.ao.quantization import",
  """--error-description=\
  Imports from torch.ao.quantization are not allowed. \
  Please import from torchao.quantization.pt2e instead.\n \
  * torchao.quantization.pt2e (includes all the utils, including observers, fake quants etc.) \n \
  * torchao.quantization.pt2e.quantizer (quantizer related objects and utils) \n \
  * torchao.quantization.pt2e.quantize_pt2e (prepare_pt2e, prepare_qat_pt2e, convert_pt2e) \n\n \
  If you need something from torch.ao.quantization, you can add your file to an exclude_patterns for TORCH_AO_IMPORT in .lintrunner.toml. \
  """,
  "--",
  "@{{PATHSFILE}}",
]

[[linter]]
code = 'ETVKNODEBUG'
include_patterns = [
    "backends/vulkan/**/*.glsl",
]
command = [
    'python',
    '-m',
    'lintrunner_adapters',
    'run',
    'grep_linter',
    '--pattern=((DEBUG_MODE)|(GL_EXT_debug_printf))',
    '--linter-name=ETVKNODEBUG',
    '--error-name=Using DEBUG_MODE or GL_EXT_debug_printf in Vulkan shader',
    """--error-description=\
        #define DEBUG_MODE or #extension GL_EXT_debug_printf should only be used during development!
    """,
    '--',
    '@{{PATHSFILE}}',
]

[[linter]]
code = 'ETVKJSONFORMAT'
include_patterns = [
    'backends/vulkan/test/ops/benchmark_v2/**/*.json',
]
command = [
    'python',
    'backends/vulkan/test/ops/benchmark_v2/format_json.py',
    '--lintrunner',
    '@{{PATHSFILE}}',
]
is_formatter = true

[[linter]]
code = 'RUFF_DOCS'
include_patterns = [
  'backends/arm/__init__.py',
  'backends/arm/common/arm_compile_spec.py',
  'backends/arm/ethosu/**/*.py',
  'backends/arm/quantizer/__init__.py',
  'backends/arm/quantizer/arm_quantizer.py',
  'backends/arm/tosa/partitioner.py',
  'backends/arm/vgf/**/*.py',
]
exclude_patterns = [
  'third-party/**',
  '**/third-party/**',
]
command = [
  'python',
  '-m',
  'lintrunner_adapters',
  'run',
  'ruff_linter',
  '--config=pyproject.toml',
  '--',
  '@{{PATHSFILE}}',
]
init_command = [
  'python',
  '-m',
  'lintrunner_adapters',
  'run',
  'pip_init',
  '--dry-run={{DRYRUN}}',
  '--requirement=requirements-lintrunner.txt',
]

[[linter]]
code = 'DOCFORMATTER'
include_patterns = ['backends/arm/**/*.py']
exclude_patterns = [
  'third-party/**',
  '**/third-party/**',
]
command = [
  'python','-m','lintrunner_adapters','run','docformatter_linter','--config=pyproject.toml','--','@{{PATHSFILE}}'
]
init_command = [
  'python','-m','lintrunner_adapters','run','pip_init',
  '--dry-run={{DRYRUN}}',
  '--requirement=requirements-lintrunner.txt',
]
is_formatter = true


[[linter]]
code = 'CPP_BANNED_FUNCTIONS'
include_patterns = [
    'backends/arm/**/*.c',
    'backends/arm/**/*.cc',
    'backends/arm/**/*.cpp',
    'backends/arm/**/*.h',
    'backends/arm/**/*.hpp',
    'examples/arm/**/*.c',
    'examples/arm/**/*.cc',
    'examples/arm/**/*.cpp',
    'examples/arm/**/*.h',
    'examples/arm/**/*.hpp',
]
exclude_patterns = [
    'third-party/**',
    '**/third-party/**',
]
command = [
    'python',
    '-m',
    'lintrunner_adapters',
    'run',
    'cpp_banned_functions_linter',
    '--config=backends/arm/scripts/banned_functions.json',
    '--',
    '@{{PATHSFILE}}',
]