日本ソフトウェア科学会第 37 回大会 (2020 年度) 講演論文集

Attempts on applying graph neural network to
cross-language code-clone detection
Yao Xuyang, Shigeru Chiba
クロスプラットフォームアプリケーションやソフトウェアの移植が増加しているため，異なるプログラミング言語の間での機能の重複は回避できなくなってきている．これらのようにプログラミング言語が異なる類似したコードの繰
り返しは言語間コードクローンとして知られている．複数のプログラミング言語の間での言語間コードクローンの検出はクロスプラットフォームアプリケーションのバージョンコントロールやバグ修正のために非常に重要である．しかし言語間コードクローンはふつう構文的にはあまり似ていない．このことが検出を難しくしている．この問題領域ではすでに多くの研究が行われている．その中のいくつかはソースコードの構文的構造，抽象構文木 (Abstract
Syntax Tree, AST) を用いる．これは AST が，プログラミング言語が異なるにも関わらずコードクローンの類似性を共有すると思われるからである．一方で，同一言語のコードクローン検出にグラフの構造情報を抽出できる革新的なコンセプトであるグラフニューラルネットワーク (Graph Neural Network, GNN) を利用する研究も進められており，多くの結果を残している．我々の研究では GNN モデルを言語間コードクローン検出に適用しようと試みる．本論文ではいくつかのモデルの設定と関連する実験と結果，そして今後の構想を示す．

Due to the increase in cross-platform applications and the transplantation of software, repetitions of functionality in diﬀerent programming languages become unavoidable. These repetitions of similar code in
diﬀerent programming languages are known as cross-language code-clones. Detecting cross-language codeclones implemented in diﬀerent programming languages is vital for tasks like version control and bug ﬁxing
for cross-platform applications. However, cross-language code-clones are usually syntactically diﬀerent toeach other which make them diﬃcult to be detected. Many studies have already been conducted in this area,some of them work on abstract syntax tree (AST), a syntactical structure of source code, which may sharesome similarity between code-clones despite of the diﬀerence in programming language. Meanwhile, there
has been researches conducted on monolingual code-clone detection utilizing a novel concept called Graph
Neural Network (GNN), which is capable of extracting structural information from graphs and achieved
signiﬁcant progress. In this work, we tried to apply a GNN model to the task of cross-language code-clone
detection. This paper will be about several model settings and corresponding experiments and results,
ﬁnishing with some future thoughts yet to be ﬁnished or conducted.

even runtime eﬃciency. With the development of

1 Introduction

cross-platform applications and increase of pack-Code-clones refers to pairs of code fragments thatage transplanting among programming languages,

share some level of syntactical or semantical simi-code-clones are occurring more and more frequently

larity. Undiscovered code-clones can cause poten-

among diﬀerent languages. Thus there has been ris-tial problems in bug ﬁxing, version maintenance oring demand on eﬃciently detecting cross-language
code-clones.

∗ グラフニューラルネットワークを言語間コードクローン

検出に適用する試み
This is an unrefered paper. Copyrights belong to
the Author(s).
姚 旭楊, 千葉 滋, 東京大学大学院情報理工学系研究科,
Graduate School of Information Science and Technology, University of Tokyo .

However, the diﬀerence of syntax and keywords
between programming languages greatly stressed
the diﬃculty of syntactical detection of crosslanguage code-clones, which makes the monolingual
code-clone detection approaches no longer feasible

on the cross-language task. Currently, in order toerogeneous graphs.

detect semantical similarity between cross-language

The remainder of this paper is arranged as fol-code pairs, many recent works has been utilizing

low. In section 2 we describe our motivation ofintermediates such as Control Flow Graph (CFG)

choosing to apply GNN models on ASTs. Thenand Abstract Syntax Tree (AST) which contains

in section 3 we present the implementation of ourcode semantics in their structure. The literaturemodel. The experiments and results are provided[4] compared the similarity of source code by di-in section 4, following with comparison with a close

rectly comparing a modiﬁed AST; the literature

work [7] section 5. Finally in section 6, we will give[5] generated vector representation for ASTs witha conclusion to this paper and talk about our plana recurrent neural network (RNN) model with longfor next step.

short-term memory (LSTM) to compute their similarity.
On the other hand, a new class of deep learning

2 Extracting semantic informationfrom ASTs

model, Graph Neural Network (GNN), has been

In this work, we aim to detect cross-language

proposed. GNN is a class of connectionist models

code-clones by extracting semantic informationthat capture the dependence of graphs via message

from abstract syntax tree (AST) with graph neuralpassing between the nodes of graphs. Due to its ca-

network (GNN) models. Clone detection has been

pability of process non-linear graph structures, wea long studied topic and there has been promisingbelieve GNN is also feasible for extracting informa-

results on syntactical similar code-clone detection.

tion and comparing similarity of ASTs. Although

However, it remains an unsolved problem to eﬃ-

plenty of GNN models has been proposed, as far as

ciently detect code-clones that are similar in seman-

we know currently there is no precedent on apply-

tics but diﬀerent in syntax, especially when they are

ing them to cross-language code-clone detection.

from diﬀerent languages. Based on existing GNN

In this paper, we present our attempt on propos-

models, we propose to train an embedding genera-ing a GNN based model for detecting cross-tor that projects code fragments into a latent spacelanguage code-clones. Our model is expected toaccording to their functionality. Thus similarity ofgenerate embeddings from ASTs, which could becode pairs can be computed with their embeddings,

used to compute the similarity between correspond-even if they are from diﬀerent languages.

ing code fragments.We build the model by imple-

Code-clones are commonly classiﬁed into four

menting and modifying existing GNN models, andtypes. While Type I-III clones share much similar-

training them with specially designed data set. Our

ity on their source code, Type IV and weak Typework mainly contributes as follows:

III code-clones can be quite diﬀerent on the text.

• To the best of our knowledge, we are the ﬁrst

Due to the fundamental diﬀerence in syntax be-

to attempt applying GNN models on cross-tween programming languages, all cross-language

language code-clone detection.

code-clones are classiﬁed into Type IV. In order• We tried to automate the code embedding

to detect such clones, semantical information usu-

stage by data augmentation, without the needally matters more than syntactical details. Thusof a huge well-labeled data set.

it has become a common approach to detect Type• We studied the possibility of graph neural network models detecting similarity between het-IV, especially cross-language code-clones, by utilizing Abstract Syntax Tree (AST).

Figure 1

Overview of our proposed cross-language code-clone model. In this work, we implement

the node embedding and graph embedding stage by localizing existing GNN models, and focus on
the design of data set and the mapping stage to overcome the structural diﬀerence between ASTs
from diﬀerent programming languages.

AST is a tree representation of the abstract syn-pared with Smith-Waterman local sequence align-

tactic structure of source code written in program-ment algorithm. [7] ﬂattened the tree structure inming language.

By ”abstracting” the ”syntax”,

the depth order so that it can be fed in to a recur-

ASTs ignore most of the text level details while

rent neural network (RNN) with long short-termpreserving the structure of the source code. Typ-memory (LSTM).

ically, indentation in Python and curled brackets

On the other hand, graph neural network is a

in Java which preserves the block information willclass of model that take graphs as direct inputs andonly result in the parent-children relationship in an

extract their structural information, in the case of

AST. Thus it is a common case where diﬀerent code

code fragment, semantic information. For a typicalfragment may share roughly similar ASTs.

GNN model, it gathers information of each node

There are more advantages for representing codeand its neighbors as the ﬁnal node embedding out-

with AST. In an AST, each node is linked with its

put. In the case of AST, such neighborhood in-neighbors in a clear hierarchical structure, which

formation of each node is expected to represent a

may further indicate the general functionality ofpartial functionality of the source code. Finally,

the corresponding block of code. In other words, a

we believe aggregating the node embeddings would

small neighborhood of nodes in an AST could pos-

generate a representation that acts as a ‘summary’sibly present the information contained in a longof the source code functionality, which can be uti-sequence of tokens. Moreover, due to the hierar-

lized for code-clone detection.

chical structure of AST, it’s easy to extract infor-

3 AST embedding models

mation for diﬀerent granularity of the source code,

In this section we will describe the models we pro-

simply by starting from diﬀerent node.

posed for the task of cross-language code-clone de-Due to the non-linear tree structure of AST, it

tection. Our general idea is to generate embeddings

cannot be directly processed by common linear ap-

for code fragments from diﬀerent languages thatproaches. There have been diﬀerent attempts onfollows same local distribution. Then we projectcomputing the similarity between ASTs. [6] lin-

the embeddings of one programming language toearized the AST with traverse of a certain orderthe other with a mapping function to blur theso that the resulted linear sequence can be com-

language-wise diﬀerence, so that similar code from

diﬀerent programming languages could have close
embeddings.

munity membership.
However, DeepWalk is a embedding model for

Our embedding model consists of node embed-

single graph, and it lacks generalization ability

ding and graph embedding. For the node embed-

across graphs, which means for the same node la-ding stage, we implemented the existing GNN mod-bel in diﬀerent graphs, it’s very likely that Deep-els DeepWalk [6] and GraphSage [1] for compari-

Walk will generate diﬀerent embedding. So we ﬁrst

son. Since the DeepWalk model is originally de-treated the whole data set as a single disconnected

signed for single graph node embedding generation,

graph. To make the training process more intu-

we specially modiﬁed the structure of data to ﬁt theitive, we further combined all the nodes with same

input for the DeepWalk model. For the graph em-label into a single node. And we assigned the num-

bedding stage we modiﬁed the gated readout func-

ber of occurrences of each edge as its weight, thus

tion proposed in the GGNN model [3]. Then weduring the random walk stage, the probability of

trained our model with a data set generated withchoosing each neighbor node will be proportional

special augmentation rule. Finally, since it’s anto the weight of the edge. In order to generate sim-

early attempt, we simply applied a MLP as theilar embedding for diﬀerent diﬀerent programming

mapping function.

languages, in our case Python and Java, we further

In the remainder of this section, we ﬁrst describe
the setting of the node embedding and graph embedding model. Then we introduce our idea fordata augmentation and embedding mapping.

merged similar nodes, e.g. IF node in Python andJava.
As our expectation, a collection of information
in a certain neighborhood of AST could represent
local functionality. In this model setting, gener-

3. 1 Node embedding modelated node embeddings are shared across all ASTs

In this stage, we re-implemented two existing

after the training phase.

For the embedding of

GNN models [1] [6] for node embedding. The aim ofeach node, it generalizes all possible situation ofthis stage is to capture the structural information

functionality with occurrence of the node, insteadfrom the neighborhood of each model, which couldof representing the speciﬁc local functionality ofpotentially indicate the local functionality. The re-the node in a certain AST. In such case, the pro-sults generated by the two models are used for the

posed model blurs the diﬀerences in usage of thenext stage respectively, for comparison.

same node. And since node embedding network

3. 1. 1 DeepWalk

is learned in an unsupervised way and is separated

DeepWalk [6] is a commonly used approach forfrom graph embedding network, this model requires

generating latent representation of vertices in a

relevantly less computational cost.

graph. For each training step, starting from an ar-

3. 1. 2 GraphSage

bitrary node, the model randomly picks a route of

In order to capture more code-dependent local

certain hops according to some pre-designed tran-

functionality information, we applied the Graph-sition rule. This route is called a random walk, andSage[13] model to generate node embedding. In-

it’s treated as the equivalent of a sentence. Then

stead of extracting substructure from the graph,

the generated sentences are considered as a spe-

the GraphSage model directly learns a function

cial language, and processed by a neural languagethat generates embeddings by sampling and ag-

model to capture neighborhood similarity and com-

gregating features from a node’s local neighbor-hood. With the constraint of the same generation

By the observation that in an AST, the nodes

function, GraphSage model is capable of generat-closer to the root node usually have a closer rela-ing stable (slightly diﬀerent according to neighbor-tionship to the main function of the code, we also

hood structure) for same node label across diﬀerent

trained a weight parameter for each layer of thegraphs.

AST to utilize the structural information:

However, GraphSage is a supervised learninghG = M LPG (graph classiﬁcation step of our model. Instead of

δ(M LPgate (hi ))⊙M LP (hi )×layer(i))

i∈Vmodel which requires labels (typically classiﬁcation) for each node, which is not required in the∑(2)where layer(i) refers to the weight parameter of thelayer of node i.

training the node embedding before aggregatingthem for graph embedding, we directly aggregate
the untrained node embeddings and train the node
embedding network and graph embedding network
together by providing graph-wise labels.

3. 3 Learning code space
Unlike common classiﬁcation tasks, code-clone
detection task is a pair-wise classiﬁcation task
where there is no certain label for each single code.

This model focus more on the speciﬁc local structure of each individual AST, and the node label
does not take signiﬁcant part in the output. So
we tried both separated and merged node labels ingenerating embeddings for diﬀerent programming
languages.

Instead of mapping the input code fragments into
a ﬁnite set of discrete class, our model intend
to project them into an inﬁnite continuous latent
space, where the distance between each pair of embedding indicates the similarity of the corresponding code fragments. This can be achieved with pairwise labels using a deep similarity learning method

3. 2 Graph embedding model

called TripletMarginLoss[15]:With the generated node embedding as local in-

LT riplet (E, E + , E − ) = max(d(E, E − )−d(E, E + ), m)

formation, we further apply an aggregation function to compute graph embedding as a ‘summary’(3)
Given an arbitrary output embedding E, and em-of the corresponding code fragment. In this work,

beddings from a positive sample E + and a nega-

we used the aggregation model proposed in the lit-

tive sample E − , the loss function encourage theerature [3]:distance between negative pairs d(E, E − ) to be

hG = M LPG (∑δ(M LPgate (hi )) ⊙ M LP (hi ))greater than positive pairs d(E, E + ) by a least a(1)

margin m. However, the clone pairs given by com-i∈V

Intuitively, this model works as an aggregation

mon code clone data sets are usually too similar,

function with attention mechanism. First the nodeand the positive samples are limited to the clone

embedding is processed by a simple MLP. At thepairs. An ideal data set should contain a relative

same time, it go through a Gate network M LPgate

distance ’label’ for arbitrary pair of code, which iswhich outputs a importance weight for each dimen-

not available.

sion of the processed node embedding. Finally all

In this work, we propose to inject positive andthe weighted node embedding is aggregated (sum,negative samples to the original data set by uti-

average, max pooling, etc.) and output through alizing data augmentation. Currently the injected

ﬁnal aggregation network M LPG .

samples are generated by changing node types andFigure 2

General idea for latent space learning and mapping. In ﬁgure (a), solid lines represents

the training phase, closer distance between embeddings indicates higher similarity between
corresponding code fragments. Dotted line shows when the model tries to embed a new codefragment unseen in the data set. Figure (b) shows the mapping stage designed for cross-language
code-clone detection. By mapping embeddings from one language cluster to another, we implicitly
remove the language-wise diﬀerence in the embeddings.

moving edges between nodes randomly. Positive

guages are distributed separately due to the struc-samples are generated with lower probability oftural diﬀerence of AST, they should obey same lo-changing, and nodes are more likely to be replacedcal distribution rule according to their semantics.

by similar types, e.g. replacing FOR with While.

Thus, we further proposes a mapping function that

Negative samples are generated with higher chang-attempts to map the latent representation of one

ing probability and randomness.

language to the other in order to blur the languagewise diﬀerence.

3. 4 Mapping function

4 Experiments & Results

The graph embedding generated by the previous

In this section we present the experiments westeps captures not only semantic information of the

conducted and the current result of our models

source code, but also the structure style of AST ofon both monolingual and cross-language code-clone

the certain language. In the monolingual case, em-

detection. Though we did not achieve a promising

beddings from diﬀerent code fragments share theresult on the cross-language task, we tried to provesame language style information, thus the diﬀer-

the feasibility of our approach, thus we argue thatence between embedding pairs can be regarded asapplying GNN models on such task is an idea worth

semantic diﬀerence. But in cross-language situa-

trying, and there is much space for improvement for

tion, the language-wise diﬀerence is too signiﬁcant

our model.

to be ignored. However, according to our expectation, though code embeddings from diﬀerent lan-

4. 1 Monolingual clone detection
4. 1. 1 Experiment settings

step.
We train the model for 20 epochs with adaptive

We believe being able to detect monolingual

learning rate (the decrease speed of loss becomes

code-clone is a precondition for a model to detectslow enough according to observation). We com-cross-language code-clones, so we started from thepute the similarity score with normalized Euclidean

former task. We used two data sets for the mono-

distance and set the threshold to 0.6 for LeetCodelingual code-clone detection task, one crawled fromdata set and 0.8 for BigCloneBench (code pairs

LeetCode[9] containing answers written in Python

with score lower than 0.8 are considered clone).

and Java for 100 diﬀerent questions, and the data

4. 1. 2 Results

set from BigCloneBench[10] benchmark.

On the crawled LeetCode data set, our model

For the data set crawled from LeetCode, we in-managed to detect all injected positive clones, while

jected positive and negative samples by data aug-

classifying some of the negative pairs as clones.

mentation, with adding, removing and switching of

However, we have to mention that in the aug-

nodes (sub-trees) by a speciﬁc probability. Duringmented data set, only the original injected samples

the training and testing phase, only the original

will be selected as positive or negative pairs, whichsample and injected positive and negative samples

could cause bias on the result.

are labeled as positive and negative pairs respec-

For test on the BigCloneBench, we used thetively. We will discuss about this limitation in sec-

testing tool BigCloneEval provided by the author.

tion 6.We used 70% of the data set for training,

Though trained with a totally diﬀerent data set,

15% for testing and 15% for validation.

our model still managed to detect most of the Type-

BigCloneBench is a widely used large code clone
benchmark that contains over 6,000,000 true clone
pairs and 260,000 false clone pairs from 10 different functionalities extracted from Java projects.
BigCloneBench mainly contains Type-3 and Type4 clones, thus is appropriate for testing semantic

Table 1Monolingual result on

crawled LeetCode data set

model

precision

recallDeepWalk

0.88

1GraphSage

0.91

1

code-clone detection models. In this work, insteadof separating the data set of BigCloneBench intotraining and testing data set, we trained the model

Table 2

Cross-language result on
BigCloneBench

Recall Per Clone Typewith the LeetCode data set and tested it with BigCloneBench, in order to prove the generalization
ability of the proposed model.
We implemented the DeepWalk and GraphSage
model following the source code from github repository[11,16].

We refer our models implement-

ing DeepWalk and GraphSage as DeepWalk andGraphSage respectively, in the remainder of thispaper. We used 3-layer MLPs with activation function ReLU for the readout function, gate function
and aggregation function in the ﬁnal aggregation

Clone types

recallType-11.0Type-21.0Type-2 (blind)

1.0Type-2 (consistent)

1.0

Very-Strongly Type-3

1.0Strongly Type-3

0.9816Moderately Type-3

0.8907

Weakly Type-3/Type-4

0.5117

(a) Language-wise distribution
Figure 3(b) File name distribution

An example of the code embedding generated by the GraphSage model. (a) shows the

distribution of code fragments from diﬀerent languages, where red dots stand for Java and blue
dots stand for Python. (b) shows the distribution of code fragments by their ﬁle index, where
darker dots corresponds to greater index, however, ﬁle index has no direct relationship to thefunctionality of code fragment. While language-wise clustering is obvious, it’s almost impossible toobserve any distribution patter inside the clusters.

3 clones, failing mostly on weakly Type-3/Type-4

the Curve (AUC) score.

clones. This proves the feasibility of our model on

4. 2. 2 Resultsmonolingual code-clone detection task despite theIt’s a pity to admit we did not acquire promis-

bias on the training data set.

ing result in the experiment for detecting crosslanguage code-clones.

4. 2 Cross-language clone detection

The training of code embedding model ﬁnished4. 2. 1 Experiment settingsnormally.

For detecting cross-language code-clones, ﬁrst we

model implementing DeepWalk and GraphSage re-project the code fragments from each programming

spectively. However, the training of mapping func-

language to independent latent spaces with the em-tion on both embedding set failed to converge. The

bedding generation model. Again we used Deep-loss of mapping function on both embedding set os-

Walk and GraphSage respectively as the node em-

cillate around 0.4-1.5. In the evaluation, while thebedding model.

The experiment setting of thismodel implementing DeepWalk got an AUC scorestage exactly follows the monolingual setting. Thenof 0.5, the AUC score for the model implementing

we map one of the latent space into the other with

GraphSage occasionally reaches 0.58-0.6, indicat-

a mapping function. We used a simple 3-layer MLP

ing it works slightly better by capturing individual

as the mapping function. In order to The embed-

structure of code fragment.

We generated code embedding withding model and mapping function is trained sepa-

For the embedding generated by the GraphSage

rately. Finally, for a pair of randomly sampled code

model, we put the vector representation of Python

fragments, we compute the distance of their embed-

and Java code together to observe the pattern. The

ding and compare it with the threshold to judge ifmodel generated clearly separated embedding forthey are clone or not. For performance evaluation,

Python and Java, which means the model is capa-

we randomly sampled positive and negative codeble of distinguishing language-wise structure diﬀer-

pairs at a ratio of 1:5, and computed Area Under

ence even without explicit training. But there is nosign of speciﬁc pattern inside each language cluster
which is required for code-clone detection.

6 Conclusion & Future work
As proved in the literature [7], GNN models can

5 Related work

be a powerful tool for monolingual code-clone de-

The literature [7] is the most recent work try-

tection. In our work, we would like to further argue

ing to solve monolingual code-clone detection taskthat GNN is also a proper choice for cross-languagewith GNN model. As the ﬁrst try on detecting

code-clone detection. By the preliminary exper-

code-clones with GNN, they reached very promis-

iments and results, we show that a GNN model

ing result with their proposed model. Instead ofcan project the code fragments into a latent space,working directly on ASTs, they designed a novel

but the information preserved by that projection

graph representation form FA-AST for Java pro-greatly depends on the data set and the design ofgrams by adding control ﬂow edges and data ﬂow

training stage.

edges to enrich potential information contain in the

Currently in our proposed model:

original ASTs. For the GNN model, they applied• the possible range of input sampling is severely

GGNN [3] and graph matching network GMN [2] ascomparison model, and ﬁnally reached better resultwith the GMN model.
Unlike typical GNN models that generate node

limited by the augmented data set• what the model can learn from the data set isgreatly biased due to the sub-optimal rule ofdata augmentation

embedding or graph embedding for a single graph• the mapping function is too simple that mighteach inference time, GMN model takes a pair of

not be capable of blurring the language-wisegraphs as input each time, and conducts a pair-diﬀerence

wise classiﬁcation. Due to the pair-wise attention

Despite these unsolved problems, we still in-mechanism, a GMN model is capable of capturingsist that a proper embedding model for generating

general similarity of a pair of graphs while focusing

language-irrelevant embeddings can be proposedon detailed key diﬀerences. Thus by applying thebase on GNN models. In the future, we will fo-

GMN model, the literature [7] managed to detect

cus on overcoming the listed diﬃculties to improvestructurally similar negative samples and positive

the performance of our model.

samples that only share detailed similarity.
However, as a monolingual code-clone detector,[10] requires well labeled data set to work properly.
Besides, since GMN is a pair-wise classiﬁer, theembedding it generated for each graph depends on
the input pair thus each inference process requires
a complete work procedure of the whole model,
and the generated embeddings cannot be reused inother situation. For the cross-language code-clone
task, the graph structure for ASTs from diﬀerent
languages diﬀers too much for the pair-wise attention mechanism to work correctly.

参 考 文 献[1] Hamilton, W., Ying, Z., and Leskovec, J.: Inductive representation learning on large graphs, Advances in neural information processing systems,
2017, pp. 1024–1034.
[2] Li, Y., Gu, C., Dullien, T., Vinyals, O., and Kohli,
P.: Graph matching networks for learning the similarity of graph structured objects, arXiv preprint
arXiv:1904.12787, (2019).
[3] Li, Y., Tarlow, D., Brockschmidt, M., and Zemel,
R.: Gated graph sequence neural networks, arXiv
preprint arXiv:1511.05493, (2015).
[4] Nichols, L., Emre, M., and Hardekopf, B.: Structural and Nominal Cross-Language Clone Detection, Fundamental Approaches to Software Engineering, Hähnle, R. and van der Aalst, W.(eds.),
Cham, Springer International Publishing, 2019,pp. 247–263.
[5] Perez, D. and Chiba, S.: Cross-language clone
detection by learning over abstract syntax trees,
2019 IEEE/ACM 16th International Conference on
Mining Software Repositories (MSR), IEEE, 2019,
pp. 518–528.
[6] Perozzi, B., Al-Rfou, R., and Skiena, S.: Deepwalk: Online learning of social representations, Proceedings of the 20th ACM SIGKDD international

conference on Knowledge discovery and data mining, 2014, pp. 701–710.
[7] Wang, W., Li, G., Ma, B., Xia, X., and Jin, Z.:
Detecting Code Clones with Graph Neural Network
and Flow-Augmented Abstract Syntax Tree, 2020
IEEE 27th International Conference on Software
Analysis, Evolution and Reengineering (SANER),
2020, pp. 261–271.