add functionality to scan for code clones?

[danylo-safonov-solid]

title

[solid-illiaaihistov]

Proposal for Implementing Code Duplication Rules

---

1. Main Rule: avoid-duplicate-code (File-Level Clones)

It is proposed to implement the avoid-duplicate-code rule, which analyzes a file for structural duplicates (clones) at the level of function/method/constructor bodies or individual statement blocks (such as loop bodies, branches of conditional statements, etc.).

Concept and Architecture

The rule is based on AST-based structural clone detection (identifying clones at the Abstract Syntax Tree level). This approach is an industry standard:

• It does not simply compare raw text (like a basic diff), but builds a structural "skeleton" of the code.
• It detects Type-2 Clones (structural or alpha-equivalent clones) — copies of code where the developer renamed variables, types, or literals but kept the identical algorithm.

A similar conceptual approach is found in other analysis tools:

• DCM (check-code-duplication): Performs a similar AST-based structural analysis, which is resilient to parameter renaming. Our proposal adapts this AST-based approach for real-time analysis within a single analyzed file (analyzer plugin context).
• PMD CPD: Uses a token-based approach (using suffix trees) rather than ASTs. However, the normalization logic of our parameters (ignore_literals and ignore_identifiers) is conceptually identical to CPD's flags (--ignore-literals and --ignore-identifiers), which abstract away lexical differences to find Type-2 structural clones.

Standard Code Clone Classification (Roy & Cordy Taxonomy):

1. Type-1 (Exact Clones) — identical code fragments (only variations in formatting, spacing, and comments are allowed).
2. Type-2 (Structural Clones) — syntactically and structurally identical code fragments, but with changes in the names of identifiers (variables, functions, classes), types, or literal values (numbers, strings). This is the primary target of our rule.
3. Type-3 (Modified Clones) — copied code fragments with modifications: in addition to identifier renames, statements or operators have been added, removed, or modified.
4. Type-4 (Semantic Clones) — code fragments that perform the same computation or logical function, but are implemented using completely different syntactic structures (e.g., bubble sort vs. quicksort).

Rule Configuration Parameters

For integration flexibility, the following parameters are proposed to be supported in analysis_options.yaml:

avoid_duplicate_code:
  min_statements: 10      # Minimum statements inside a block to check
  ignore_literals: true   # Ignore literal values (Type-2 clones)
  ignore_identifiers: true # Ignore variable/method names (Type-2 clones)
  check_blocks: true      # Also check nested statement blocks (if, loops, etc.)
  exclude:                # Exclude specific methods
    - method_name: build

NOTE
Default Value Selection: By default, min_statements is set to 10 (matching SonarQube's industry standard). This threshold ensures the linter remains low-noise, ignoring trivial 3-to-5 line setup logic (such as small getters or controllers) and only flagging non-trivial duplicate algorithms that warrant refactoring.

Examples of Rule Application

A. Duplicated Function Bodies (Type-2 Clone)

Detects methods with the same algorithmic structure, even if the developer renamed variables, types, or literal strings.

• Violation (Bad):

  void logUserAction(User user) {
    final time = DateTime.now();
    print('[$time] User ${user.name} performed action.');
    saveToDatabase(user.id, time);
  }
  
  void logAdminAction(Admin admin) {
    final current = DateTime.now();
    print('[$current] Admin ${admin.fullName} performed action.');
    saveToDatabase(admin.adminId, current);
  }

  The linter will highlight the declaration of the logAdminAction method as a duplicate of the logUserAction method.

• Refactored (Good) — Extracting shared logic:

  void _logAction(String name, String id) {
    final time = DateTime.now();
    print('[$time] $name performed action.');
    saveToDatabase(id, time);
  }
  
  void logUserAction(User user) => _logAction(user.name, user.id);
  void logAdminAction(Admin admin) => _logAction(admin.fullName, admin.adminId);

B. Duplicated Nested Blocks (when check_blocks: true)

Detects identical statement blocks (e.g., parameter validation or loops) within completely different functions.

• Violation (Bad):

  void updateProfile(User user) {
    // Validation block
    if (user.age < 18 || user.name.isEmpty || user.email.isEmpty) {
      throw ArgumentError('Invalid user data');
    }
    _saveProfile(user);
  }
  
  void registerUser(User user) {
    // Identical validation block
    if (user.age < 18 || user.name.isEmpty || user.email.isEmpty) {
      throw ArgumentError('Invalid user data');
    }
    _createNewUser(user);
  }

  The linter will highlight the if-statement block inside the registerUser method as a duplicate.

• Refactored (Good) — Extracting validation:

  void _validateUser(User user) {
    if (user.age < 18 || user.name.isEmpty || user.email.isEmpty) {
      throw ArgumentError('Invalid user data');
    }
  }
  
  void updateProfile(User user) {
    _validateUser(user);
    _saveProfile(user);
  }
  
  void registerUser(User user) {
    _validateUser(user);
    _createNewUser(user);
  }

---

2. Additional Micro-Rules to Prevent Duplication

Apart from analyzing larger algorithmic blocks, it is proposed to add 4 specific rules to detect duplication at a micro-level. They are focused on preventing common logical errors and typos.

Rule Name	Category	Official Counterpart (DCM)	Description
avoid-duplicate-collection-elements	Common	avoid-duplicate-collection-elements	Disallows duplicate elements inside collections (List, Set, Map).
avoid-duplicate-initializers	Common	avoid-duplicate-initializers	Detects variables inside the same scope initialized with identical expressions.
avoid-duplicate-constant-values	Common	avoid-duplicate-constant-values	Finds duplicate values in class constants or enum constructors.
avoid-duplicate-cascades	Common	avoid-duplicate-cascades	Detects identical consecutive calls in cascade notation ...

Detailed Description and Rule Examples

A. avoid-duplicate-collection-elements

Helps avoid logic bugs in lists or sets, where duplicate elements are often the result of accidental line copying (copy-paste typo).

• Violation (Bad):

  const menu = {'home', 'profile', 'settings', 'profile'}; // Duplicate 'profile'

• Corrected (Good):

  const menu = {'home', 'profile', 'settings', 'logout'};

B. avoid-duplicate-initializers

Prevents creating redundant variables with identical values. Encourages developers to reuse already computed local variables.

• Violation (Bad):

  final area = width * height;
  final size = width * height; // Duplicates the same expression

• Corrected (Good):

  final area = width * height;
  final size = area; // Reuses the computed variable

C. avoid-duplicate-constant-values

Prevents situations where different configuration constants have identical hardcoded values, making future maintenance more difficult.

• Violation (Bad):

  class ApiConfig {
    static const readTimeout = 30;
    static const writeTimeout = 30; // Duplicates constant value
  }

• Corrected (Good):

  class ApiConfig {
    static const readTimeout = 30;
    static const writeTimeout = readTimeout; // Binds constants together
  }

D. avoid-duplicate-cascades

Detects typos where copying code causes the same method or setter to be called with identical parameters multiple times on the same object.

• Violation (Bad):

  final user = User()
    ..name = 'Alice'
    ..name = 'Alice'; // Duplicates cascade assignment

• Corrected (Good):

  final user = User()
    ..name = 'Alice'
    ..role = 'Admin';

---

3. Sources and Useful Links

• Code Clone Classification (Roy & Cordy):
  • A Survey on Software Clone Detection Research (PDF) — Queen's University (Canada) technical report, the world standard for defining and classifying Type-1, Type-2, Type-3, and Type-4 software clones (definitions on pages 3-5).
• Implementation References:
  • DCM: check-code-duplication — official documentation for the CLI command to find code duplication in Dart.
  • PMD CPD Documentation — description of the Copy/Paste Detector (CPD) algorithm and its configuration.