Aroma: Code Recommendation via Structural Code Search

TL;DR

Aroma is a code recommendation tool that uses structural code search across large open-source corpora to suggest relevant code snippets, aiding programmers in extending, fixing, and understanding code more effectively.

Contribution

Aroma introduces a novel structural code search technique for code recommendation, indexing extensive open-source code and providing efficient, contextually relevant snippet suggestions.

Findings

Aroma effectively retrieves relevant code snippets from large corpora.

Aroma's recommendations improve programmer productivity in coding tasks.

The tool performs well across multiple programming languages.

Abstract

Programmers often write code that has similarity to existing code written somewhere. A tool that could help programmers to search such similar code would be immensely useful. Such a tool could help programmers to extend partially written code snippets to completely implement necessary functionality, help to discover extensions to the partial code which are commonly included by other programmers, help to cross-check against similar code written by other programmers, or help to add extra code which would fix common mistakes and errors. We propose Aroma, a tool and technique for code recommendation via structural code search. Aroma indexes a huge code corpus including thousands of open-source projects, takes a partial code snippet as input, searches the corpus for method bodies containing the partial code snippet, and clusters and intersects the results of the search to recommend a small set of succinct code snippets which both contain the query snippet and appear as part of several methods in the corpus. We evaluated Aroma on 2000 randomly selected queries created from the corpus, as well as 64 queries derived from code snippets obtained from Stack Overflow, a popular website for discussing code. We implemented Aroma for 4 different languages, and developed an IDE plugin for Aroma. Furthermore, we conducted a study where we asked 12 programmers to complete programming tasks using Aroma, and collected their feedback. Our results indicate that Aroma is capable of retrieving and recommending relevant code snippets efficiently.

Tables

Table 1. Table 1 . Aroma code recommendation examples

Query Code Snippet	Aroma Code Recommendation with Extra Lines Highlighted
⬇ TextView textView = (TextView) view.findViewById(R.id.textview); SpannableString content = new SpannableString("Content"); content.setSpan(new UnderlineSpan(), 0, content.length(), 0); textView.setText(content);   Example A: Configuring Objects. • This code snippet adds underline to a piece of text.1 • The recommended code suggests adding a callback handler to pop up a dialog once the underlined text is touched upon. • Intersected from a cluster of 2 methods.2	⬇ TextView licenseView = (TextView) findViewById(R.id.library_license_link); SpannableString underlinedLicenseLink = new SpannableString( getString(R.string.library_license_link)); underlinedLicenseLink.setSpan(new UnderlineSpan(), 0, underlinedLicenseLink.length(), 0); licenseView.setText(underlinedLicenseLink); licenseView.setOnClickListener(v -> { FragmentManager fm = getSupportFragmentManager(); LibraryLicenseDialog libraryLicenseDlg = new LibraryLicenseDialog(); libraryLicenseDlg.show(fm, "fragment_license"); });
⬇ Bitmap bitmap = BitmapFactory.decodeResource(getResources(), R.drawable.image);   Example B: Post-Processing. • This code snippet decodes a bitmap.3 • The recommended code suggests applying Gaussian blur on the decoded image, a customary effect to be applied. • Intersected from a cluster of 4 methods.4	⬇ int radius = seekBar.getProgress(); if (radius < 1) { radius = 1; } Bitmap bitmap = BitmapFactory.decodeResource(getResources(), R.drawable.image); imageView.setImageBitmap(blur.gaussianBlur(radius, bitmap));
⬇ EditText et = (EditText)findViewById(R.id.inbox); et.setSelection(et.getText().length());   Example C: Correlated Statements. • This code snippet moves the cursor to the end in a text area.5 • The recommended code suggests also configuring the action bar to create a more focused view. • Intersected from a cluster of 2 methods.6	⬇ super.onCreate(savedInstanceState); setContentView(R.layout.material_edittext_activity_main); getSupportActionBar().setDisplayHomeAsUpEnabled(true); getSupportActionBar().setDisplayShowTitleEnabled(false); EditText singleLineEllipsisEt = (EditText) findViewById(R.id.singleLineEllipsisEt); singleLineEllipsisEt.setSelection( singleLineEllipsisEt.getText().length());
⬇ PackageInfo pInfo = getPackageManager().getPackageInfo(getPackageName(), 0); String version = pInfo.versionName;   Example D: Exact Recommendations. • This partial code snippet gets the current version of the application. The rest of the code snippet (not shown) catches and handles possible NameNotFound errors.7 • The recommended code suggests the exact same error handling as in the original code snippet. • Intersected from a cluster of 2 methods.8	⬇ try { PackageInfo pInfo = getPackageManager().getPackageInfo(getPackageName(), 0); String version = pInfo.versionName; TextView versionView = (TextView) findViewById(R.id.about_project_version); versionView.setText("v" + version); } catch (PackageManager.NameNotFoundException ex) { Log.e(...); }
⬇ i.putExtra("parcelable_extra", (Parcelable) myParcelableObject);   Example E: Alternative Recommendations. • This partial code snippet demonstrates one way to attach an object to an Intent. The rest of the code snippet (not shown) shows a different way to serialize and attach an object.9 • Intersected from a cluster of 10 methods.10	⬇ Intent intent = new Intent(this, BoardTopicActivity.class); intent.putExtra(SMTHApplication.BOARD_OBJECT, (Parcelable) board); startActivity(intent); • The recommended code does not suggest the other way of serializing the object, but rather suggests a common way to complete the operation by starting an activity with an Intent containing a serialized object.

Table 2. Table 2 . Features for selected tokens in Figure  4

	Token Feature	Parent Features	Sibling Features	Variable Usage Features
${\text{view}}_{30}$	#VAR	(#VAR, 2, (#)#) (#VAR, 1, (#)) (#VAR, 1, #.#)	(ViewGroup, #VAR) (#VAR, getChildCount)	((1, #instanceof#), (2, (#)#)) ((2, (#)#), (2, (#)#))
$0_{20}$	0	(0, 2, #=#) (0, 1, int#) (0, 1, #;#;#;)	(#VAR, 0) (0, #VAR)	-

Table 3. Table 3 . Categories of Aroma code recommendations

Configuring Objects	17
Error Checking and Handling	14
Post-processing	16
Correlated Statements	21
Unclustered Recommendations	5

Table 4. Table 4 . Comparison of recall between a clone detector, conventional search techniques, and Aroma

	Contiguous			Non-contiguous
	Recall@1	Recall@100		Recall@1	Recall@100
SCC	(12.2%)			(7.7%)
Keywords Search	78.3%	96.9%		93.0%	99.9%
Features Search	78.3%	96.8%		88.1%	98.6%
Aroma	99.1%	100%		98.3%	100%

Table 5. Table 5 . Aroma recall performance on different languages

	Contiguous			Non-contiguous
	Recall@1	Recall@100		Recall@1	Recall@100
Aroma for Hack	98.5%	100%		98.3%	99.9%
Aroma for JavaScript	93.9%	99.6%		not applicable
Aroma for Python	97.5%	99.4%		not applicable

Equations

$$\mathtt{cs}(\tau )=|{\cap }_{1\le j\le k}F(N_2(i_j))|$$

$$\mathtt{csq}(\tau )=|{\cap }_{1\le j\le k}F(\mathtt{Prune}(F(q),N_2(i_j)))|$$

$$tfidf(i,j)=(1+\log tf(i,j))\cdot \log \frac{J}{df(i)}$$

Full text

code recommendation, structural code search, clone detection, feature-based code representation, clustering

††copyright: rightsretained††doi: 10.1145/3360578††journalyear: 2019††journal: PACMPL††journalvolume: 3††journalnumber: OOPSLA††article: 152††publicationmonth: 10††ccs: Information systems Near-duplicate and plagiarism detection††ccs: Software and its engineering Development frameworks and environments††ccs: Software and its engineering Software post-development issues

1. Introduction

Suppose an Android programmer wants to write code to decode a bitmap. The programmer is familiar with the libraries necessary to write the code, but they are not quite sure how to write the code completely with proper error handling and suitable configurations. They write the code snippet shown in Listing 1 as a first attempt. The programmer now wants to know how others have implemented this functionality fully and correctly in related projects. Specifically, they want to know what is the customary way to extend the code so that proper setup is done, common errors are handled, and appropriate library methods are called. It would be nice if a tool could return a few code snippets shown in Listings 2, 3, which demonstrate how to configure the decoder to use less memory, and how to handle potential runtime exceptions, respectively. We call this the code recommendation problem.

There are a few existing techniques which could potentially be used to get code recommendations. For example, code-to-code search tools (Kim et al., 2018; Krugler, 2013) could retrieve relevant code snippets from a corpus using a partial code snippet as query. However, such code-to-code search tools return lots of relevant code snippets without removing or aggregating similar-looking ones. Moreover, such tools do not make any effort to carve out common and concise code snippets from similar-looking retrieved code snippets. Pattern-based code completion tools (Nguyen et al., 2009; Mover et al., 2018; Nguyen et al., 2012) mine common API usage patterns from a large corpus and use those patterns to recommend code completion for partially written programs as long as the partial program matches a prefix of a mined pattern. Such tools work well for the mined patterns; however, they cannot recommend any code outside the mined patterns—the number of mined patterns are usually limited to a few hundreds. We emphasize that the meaning of the phrase “code recommendation” in Aroma is different from the term “API code recommendation” (Nguyen et al., 2016a; Nguyen et al., 2016b). The latter is a recommendation engine for the next API method to invoke given a code change, whereas Aroma aims to recommend code snippets, as shown in Listings 2, 3, for programmers to learn common usages and integrate those usages with their own code. Aroma’s recommendations contain more syntactic variety than just API usages; for instance, the recommended code snippet in Listing 3 includes a try-catch block, and Example B in Table 1 recommends adding an if statement that modifies a variable. Code clone detectors (Sajnani et al., 2016; Cordy and Roy, 2011; Jiang et al., 2007; Kamiya et al., 2002) are another set of techniques that could potentially be used to retrieve recommended code snippets. However, code clone detection tools usually retrieve code snippets that are almost identical to a query snippet. Such retrieved code snippets may not always contain extra code which could be used to extend the query snippet.

We propose Aroma, a code recommendation engine. Given a code snippet as input query and a large corpus of code containing millions of methods, Aroma returns a set of recommended code snippets such that each recommended code snippet:

• •

contains the query snippet approximately, and

• •

is contained approximately in a non-empty set of method bodies in the corpus.

Furthermore, Aroma ensures that any two recommended code snippets are not quite similar to each other.

Aroma works by first indexing the given corpus of code. Then Aroma searches for a small set (e.g. 1000) of method bodies which contain the query code snippet approximately. A challenge in designing this search step is that a query snippet, unlike a natural language query, has structure, which should be taken into account while searching for code. Once Aroma has retrieved a small set of code snippets which approximately contain the query snippet, Aroma prunes the retrieved snippets so that the resulting pruned snippets become similar to the query snippet. It then ranks the retrieved code snippets based on the similarity of the pruned snippets to the query snippet. This step helps to rank the retrieved snippets based on how well they contain the query snippet. The step is precise, but is relatively expensive; however, the step is only performed on a small set of code snippets, making it efficient in practice. After ranking the retrieved code snippets, Aroma clusters the snippets so that similar snippets fall under the same cluster. Aroma then intersects the snippets in each cluster to carve out a maximal code snippet which is common to all the snippets in the cluster and which contains the query snippet. The set of intersected code snippets are then returned as recommended code snippets. Figure 3 shows an outline of the algorithm. For the query shown in Listing 1, Aroma recommends the code snippets shown in Listings 2, 3. The right column of Table 1 shows more examples of code snippets recommended by Aroma for the code queries shown on the left column of the table.