RefaFlex: safer refactorings for reflective Java programs

Abstract

If programs access types and members through reflection, refactoring tools cannot guarantee that refactorings on those programs are behavior preserving. Refactoring approaches for highly reflective languages like Smalltalk therefore check behavior preservation using regression testing.In this paper we propose RefaFlex, a novel and more defensive approach towards the refactoring of reflective (Java) programs. RefaFlex uses a dynamic program analysis to log reflective calls during test runs and then uses this information to proactively prevent the programmer from executing refactorings that could otherwise alter the program's behavior. This makes re-running test cases obsolete: when a refactoring is permitted, tests passing originally are guaranteed to pass for the refactored program as well. In some cases, we further re-write reflective calls, permitting refactorings that would otherwise have to be rejected.We have implemented RefaFlex as an open source Eclipse plugin and offer extensions for six Eclipse refactoring tools addressing naming, typing, and accessibility issues. Our evaluation with 21,524 refactoring runs on three open source programs shows that our tool successfully prevents 1,358 non-behaviour-preserving refactorings which the plain Eclipse refactorings would have incorrectly permitted.

On the use of type predicates in object-oriented software

“…Therefore, we analyze the execution of unit tests associated with each project. Using unit tests as scenarios for dynamic analysis has been reported also in other tools [26,29]. However, we are aware that unit test scenarios may be biased, and consequently, our dynamic analysis could be just a lower bound approximation.…”

Reflection-aware static regression test selection

“…3.2.1 Dynamic Analysis. We can obtain reflective edges dynamically as was done in previous work on reflection analysis for other testing or analysis tasks, e.g., by Bodden et al [2011] and Thies and Bodden [2012]; we refer to this technique as Dynamic Analysis. The idea is to execute the tests while instrumenting only the aforementioned four reflection methods to record the classes constructed from invocations of the reflection methods.…”

“…Many researchers studied the impact of reflection in modern programming languages on static analysis [Barros et al 2015;Bodden et al 2011;Li et al 2016aLi et al ,b, 2014Li et al , 2015bLivshits et al 2015;Thies and Bodden 2012]. However, none of the existing studies investigated the impacts of reflection in the context of RTS.…”

“…The Java standard library (JSL) methods for dynamically creating instances of B from A include Class.forName and Class.newInstance, which allow creating objects that represent classes from a string and creating instances of those classes, respectively. Although reflection is a powerful feature that makes code more extensible, it poses significant challenges for static analysis [Bodden et al 2011;Landman et al 2017;Li et al 2016aLi et al ,b, 2014Li et al , 2015bLivshits et al 2015;Thies and Bodden 2012]. In particular, for reflection-unaware (RU) static class-level RTS, the IRG would not contain reflective edges, such as from A to B.…”

Understanding and addressing exhibitionism in Java empirical research about method accessibility

“…We did not specifically measure the impact of reflection in our analysis. We plan to investigate this aspect in the future using a dynamic analysis, similarly to Thies and Bodden (2012).…”