[Paper Review] Code Clone Matching: A Practical and Effective Approach to Find Code Snippets

Katsuro Inoue, Yuya Miyamoto+2 more|arXiv (Cornell University)|Mar 12, 2020

Software Engineering Research37 references4 citations

TL;DR

This paper proposes Code Clone Matching (CC matching), a practical method that combines token-based clone detection with meta-patterns using meta-tokens (e.g., $var) to enable flexible, language-aware code snippet search. The approach powers ccgrep—a grep-like tool that efficiently finds type 1, 2, and select type 3 code clones with high precision, outperforming traditional grep and existing clone finders in usability and accuracy.

ABSTRACT

Finding the same or similar code snippets in source code is one of fundamental activities in software maintenance. Text-based pattern matching tools such as grep is frequently used for such purpose, but making proper queries for the expected result is not easy. Code clone detectors could be used but their features and result are generally excessive. In this paper, we propose Code Clone matching (CC matching for short) that employs a combination of token-based clone detection and meta-patterns enhanced with meta-tokens. The user simply gives a query code snippet possibly with a few meta-tokens and then gets the resulting snippets, forming type 1, 2, or 3 code clone pairs between the query and result. By using a code snippet with meta-tokens as the query, the resulting matches are well controlled by the users. CC matching has been implemented as a practical and efficient tool named ccgrep, with grep-like user interface. The evaluation shows that ccgrep~ is a very effective to find various kinds of code snippets.

Motivation & Objective

• To address the limitations of grep in finding code snippets across multiple lines and ignoring syntax elements like comments and whitespace.
• To overcome the excessive and uncontrolled output of full clone detection tools, which return too many irrelevant clones.
• To enable developers to search for specific code patterns with meta-tokens (e.g., $var) to precisely control match scope.
• To develop a practical, efficient, and user-friendly tool that supports type 1, 2, and partial type 3 clone matching.
• To provide a solution that balances precision, performance, and usability for both novice and experienced developers.

Proposed method

• The method uses token-based clone detection to normalize source code by ignoring whitespace and comments, enabling syntactic matching.
• Meta-patterns are introduced using meta-tokens (e.g., $var, $stmt) to represent variable names, statements, or expressions, allowing flexible query formulation.
• The system matches query snippets—enhanced with meta-tokens—against codebases to retrieve type 1, 2, and selected type 3 clones.
• A grep-like command-line interface is implemented in ccgrep to ensure ease of use and integration into existing workflows.
• The approach leverages tokenization and pattern matching to efficiently identify clones while preserving structural and syntactic similarity.
• The tool indexes code using token sequences and applies meta-pattern matching to reduce false positives and improve relevance.

Experimental results

Research questions

• RQ1 Can a pattern-matching system based on code clone detection improve precision and usability over traditional grep for code snippet search?
• RQ2 How effective is the use of meta-tokens in controlling the scope and specificity of code clone matches?
• RQ3 Can the system efficiently retrieve type 1, 2, and type 3 clones while maintaining performance comparable to grep?
• RQ4 How does ccgrep compare to existing tools like CBCD, NCDSearch, and Siamese in terms of speed, accuracy, and usability?
• RQ5 To what extent can meta-patterns express complex code patterns such as loops with specific control variables and embedded statements?

Key findings

• ccgrep successfully retrieves type 1, 2, and a representative subset of type 3 code clones using meta-patterns, enabling precise and flexible search.
• The tool achieves better precision than grep by filtering out irrelevant matches involving comments, whitespace, and syntactic noise.
• ccgrep’s performance is slower than grep but significantly faster than other clone finders like CBCD and NCDSearch, making it practical for interactive use.
• The evaluation confirms that meta-patterns allow users to express complex queries—such as for-loops with specific control variables and return statements—without false positives.
• ccgrep outperforms existing tools in usability and response time, particularly for ad-hoc, interactive code search tasks.
• The tool is effective in identifying similar code patterns across large codebases, supporting tasks like bug detection, refactoring, and code reuse analysis.