Code Clones

A code fragment is a contiguous segment of source code. Code clones are two or more fragments that are similar with respect to a clone type.

Type I Clones

Identical up to variations in comments, whitespace, or layout [Roy'07]

if (a >= b) {
    c = d + b; // Comment1
    d = d + 1;}
else
    c = d - a; //Comment2

if (a>=b) {
    // Comment1'
    c=d+b;
    d=d+1;}
else  // Comment2'
    c=d-a;

if (a>=b)
    { // Comment1''
    c=d+b;
    d=d+1;
    }
else  // Comment2''
    c=d-a;

Type II Clones

Identical up to variations in names and values, comments, etc. [Roy'07]

if (a >= b) {
    c = d + b; // Comment1
    d = d + 1;}
else
    c = d - a; //Comment2

if (m >= n)
    { // Comment1'
    y = x + n;
    x = x + 5; //Comment3
    }
else
    y = x - m; //Comment2'

A parameterized clone for this fragment is

Type III Clones

Modifications include statement(s) changed, added, or deleted [Roy'07]

public int getSoLinger() throws SocketException {
    Object o = impl.getOption(SocketOptions.SO_LINGER);
    if (o instanceof Integer) {
        return((Integer) o).intValue();
    }
    else return -1;
    }

public synchronized int getSoTimeout() // This statement is changed
                         throws SocketException {
    Object o = impl.getOption(SocketOptions.SO_TIMEOUT);
    if (o instanceof Integer) {
        return((Integer) o).intValue();
    }
    else return -0;
    }

Type IV Clones

Syntactically dissimilar fragments with similar functionality [Roy'07]

int i, j=1;
  for (i=1; i<=VALUE; i++)
       j=j*i;

int factorial(int n) {
 if (n == 0) return 1 ;
 else        return n * factorial(n-1) ;
}

Now consider a recursive function that calculates the factorial

Code Clone Detection Techniques

Techniques can be classified by their source code representation

• Text. Apply slight transformations; compare sequences of text

• Token. Lexically analyze the code; compare subsequences of tokens

• Metrics. Gather different metrics for fragments; compare them

• Tree. Measure similarity of subtrees in syntactical representations

• Graph. Consider the semantic information of the source code

Motivation

• Many approaches consider either structure or identifiers but none of the existing techniques model both sources of information

public int getSoLinger() throws SocketException {
    Object o = impl.getOption(SocketOptions.SO_LINGER);
    if (o instanceof Integer) {
        return((Integer) o).intValue();
    }
    else return -1;

• They depend on generic, handcrafted features to represent code
  • Frequency of keywords
  • Indentation pattern
  • Length of source code line
  • Number of shared/different AST nodes
  • q-Level atomic tree patterns in parse trees
  • Frequency of semantic node types in PDGs
  • Geometry characteristics of CFGs

Our new set of techniques fuse and use

Learning-based Paradigm

• Learn. Induce compositional representations of code; compare

• Distinguished from token-based techniques; maps terms to continuous-valued vectors and uses context

• Distinguished from tree-based techniques; operates on identifiers and learns discriminating features

Why deep learning?

Learning-based Code Clone Detection

Our approach couples deep learners to front end compiler stages

ast2bin

ASTs can have any number of levels comprising nodes with arbitrary degree. ast2bin fixes the size of the input, and recursion models different levels.

Case I

Case II

Case II

Use a grammar to handle nodes with degree greater than two

Case I

1. TypeDeclaration
2. MethodDeclaration
3. OtherType
4. ExpressionStatement
5. QualifiedName
6. SimpleType
7. SimpleName
8. ParenthesizedExpression
9. Block
10. ArtificialType

Establish a precedence to handle nodes with degree one

Recurrent Neural Networks

Effectively model sequences of terms in a source code corpus

Deep Learning Code at the Lexical Level

We use a recurrent neural network to map terms to embeddings

What we would like to have is not only embeddings for terms but also embeddings for fragments

Recursive Autoencoders

Generalize recurrent neural networks by modeling structures

Deep Learning Code at the Syntax Level

We use a recursive autoencoder to encode sequences of embeddings

AST-based encoding

Greedy encoding

Empirical Validation

• Research Questions
  1. Are our representations suitable for detecting fragments that are similar with respect to a clone type?
  2. Is there evidence that our learning-based approach is capable of recognizing clones that are undetected or suboptimally reported by a structure-oriented technique?

Subject Systems

Empirical Results - RQ1

• Are our representations suitable for detecting fragments that are similar with respect to a clone type?
• Sampled 398 from 1,500+ file pairs, 480 from 60,000+ method pairs

File-level

Method-level

Precision Results (%)

Empirical Results - RQ2

• Is there evidence that our compositional, learning-based approach is capable of recognizing clones that are undetected or suboptimally reported by a traditional, structure-oriented technique?

• For a structure-oriented technique, we selected the prominent tool Deckard [Jiang'07]
  • Suboptimally reported:  jhotdraw0
  • Undetected:  hibernate0

• We posted more examples in our online appendix