ATC Variant Builder

Detect 7.40+ syntax incompatible with downport targets

Prefer REDUCE #( ) expression over simple aggregation LOOP

Prefer table expression itab[ ... ] over READ TABLE

Prefer COND #( ) expression over IF/ELSEIF/ELSE statement

Prefer SWITCH #( ) expression over CASE statement

Prefer lines( ) over DESCRIBE TABLE ... LINES

Avoid static CALL METHOD statements

Avoid WITH DEFAULT KEY; prefer EMPTY KEY or explicit keys

Prefer IS NOT over NOT ... IS

Avoid self-reference ME->

Omit redundant EXPORTING and RECEIVING in method calls

Avoid chained declarations and chained assignments

Prefer string templates over CONCATENATE

Avoid comparing boolean method calls to boolean literals

Prefer line_exists( ) over READ TABLE with NO FIELDS

Prefer RETURN over EXIT outside loop constructs

Avoid CHECK statements; prefer IF with RETURN or CONTINUE

Avoid empty control blocks (IF, CASE, LOOP, TRY, etc.)

Avoid duplicate branch conditions in IF and CASE

Merge consecutive nested IF blocks using boolean AND

Detect unreachable code after jump or exit statements

Avoid CASE statements with only one WHEN branch

Avoid Yoda conditions in comparison expressions

Prefer symbolic operators over textual EQ, NE, LT, GT

Prefer NEW operator over CREATE OBJECT and RAISE EXCEPTION

Prefer xsdbool( ) expression over manual IF-ELSE assignment

Avoid calling static methods via instance arrow (->)

Avoid mutable public attributes in classes

Avoid obsolete statements (MOVE, REFRESH, FORM, etc.)

Prohibit classic list processing statements

Method signature cleanliness (excessive parameter count)

Avoid database access inside loop iterations

Unsecure FOR ALL ENTRIES (Missing empty itab check)

Select performance (Avoid SELECT * and SELECT ... ENDSELECT)

Avoid variable usage outside its declaring control block

Detect Identical Self Assignments

Enforce fully typed constant declarations

Prefer CORRESPONDING Expression over MOVE-CORRESPONDING

Method Length Limit (excessive statement count)

Nesting Depth Limit (excessive control block nesting)

Avoid sy-* System Variable Modification

Prefer RETURNING over single EXPORTING

Prefer Class-Based Exceptions over Classic EXCEPTIONS

Dangerous Statements (abaplint dangerous_statement)

Call Transaction Authority Check

SELECT UP TO 1 ROWS requires ORDER BY

Cyclomatic Complexity Threshold

Prefer FINAL classes and methods by default

Avoid magic numbers in code; use named constants

Prefer INSERT ... INTO TABLE over APPEND for table safety

Avoid LIKE referencing data objects; use explicit TYPE

Keep constructors clean; avoid heavy logic and DB

Avoid static-only classes; use instantiable classes

Enforce predicate naming (IS_, HAS_) on boolean methods

Avoid deep class inheritance hierarchies

Limit class member attributes to prevent God Classes

Avoid mutable DATA in interfaces; allow only CONSTANTS

Catch specific exceptions instead of generic cx_root

Avoid MESSAGE ... RAISING; use class-based exceptions

Avoid nested TRY blocks; extract to helper methods

Avoid raising SAP internal system exceptions (cx_sy_*)

Check sy-subrc after DB, table and string operations

Avoid USING CLIENT or CLIENT SPECIFIED in ABAP SQL

Avoid COMMIT and ROLLBACK in application logic

Avoid MODIFY itab in LOOP without TRANSPORTING clause

Detect obsolete string statements; prefer built-in functions

Prefer calculation assignment operators (+=, -=, *=, /=)

Prefer early return or continue over nested IF blocks

Detect unused local variables and field symbols

Enforce declaration order (TYPES, CONSTANTS, DATA, FS)

Avoid unnecessary parameter escape (!param)

Use CASE instead of IF when checking multiple values

Avoid inline length specification in declarations

Max One Statement Per Line

No Dashes in Variable and Form Names

Prefer Inline Declarations

Declare inline variables as FINAL when never written again

Avoid FRIENDS in class definitions

Use a message class instead of inline message text

Inline a CAST helper that is only read once

Classic EXCEPTIONS must not overlap

RFC calls must handle system failures

Remove redundant parentheses

Slow Parameter Passing

Modify Only Own Database Tables

No Dynamic Constructs (CALL, ASSIGN, CREATE, etc.)

Declare Constructor in PUBLIC SECTION

Place definitions at beginning of routine

Omit unnecessary RETURN at end of routine

Do not mix RETURNING with EXPORTING or CHANGING

Method name overwrites built-in SAP function

Max one method parameter definition per line

Prefer IS [NOT] INITIAL over lines( ) or empty literals

Disallow ignoring the return value of functional methods

Prefer modern CAST #( ) expression over ?=

Do not CLEAR or FREE variables redundantly

Avoid mutating or sorting tables inside loops

Avoid reading environment system fields (sy-sysid, etc.)

Maximum Line Length

Standard Naming Conventions

Expand Macro Calls

Bad Statement Indentation

Detect Dead Code with Constant Condition

Avoid Using ABAP Keywords as Identifier Names

Prefer an explicit JOIN type such as INNER JOIN

Prefer explicit TYPE STANDARD TABLE OF over TYPE TABLE OF

Prefer IS SUPPLIED over the obsolete IS REQUESTED

Prefer the short system field alias SY over SYST