Cascade: A Universal Programmer-assisted Type Qualifier Inference Tool

Transcription

1 Cascade: A Universal Programmer-assisted Type Qualifier Inference Tool Mohsen Vakilian* Amarin Phaosawasdi* Michael D. Ernst Ralph E. Johnson* *University of Illinois at Urbana-Champaign University of Washington 1

2 Type qualifiers allow additional static type checks static int MathVector ic, int l) { int i = 0; for (int k = 0; k < MathVector.NDIM; k++) { if (((int) ic.value(k) & l)!= 0) i += Cell.NSUB >> (k + 1); } return i; } 2

3 Java 8 supports custom type systems* Locking Aliasing Interning Immutability Tainting *checkerframework.org 3

4 Java 8 supports custom type systems* Locking Aliasing Interning Immutability Tainting + additional static checks *checkerframework.org 4

5 Java 8 supports custom type systems* Locking Aliasing Interning Immutability Tainting + additional static checks - additional code annotation *checkerframework.org 5

6 The manual annotation process is tedious Run type checker 6

7 The manual annotation process is tedious Run type checker Add or remove qualifiers 7

8 The manual annotation process is tedious Refactor code Run type checker Add or remove qualifiers 8

9 Type qualifier inference tools run in batch mode Program Infer Annotated program 9

10 Type qualifier inference tools run in batch mode Nullness Program Infer Annotated program Julia, Nit, JastAddJ Nullness, SALSA Nullness, Xylem, Daikon Nullness Immutability Javarifier, Pidasai, ReImInfer Ownership Universe and Ownership Type Inference System 10

11 Type qualifier inference tools run in batch mode Strengths Program Infer Annotated program Optimal under certain conditions Large change without user involvement 11

12 Type qualifier inference tools run in batch mode Weaknesses Program Infer Annotated program Limited to one set of qualifiers Unpredictable Rigid Inaccurate 12

13 Type qualifier inference tools run in batch mode Refactor code Program Infer Annotated program Run type checker Add or remove qualifiers 13

14 Type qualifier inference tools run in batch mode Refactor code Program Infer Automate! Annotated program Run type checker Add or remove qualifiers 14

15 Type qualifier inference tools run in batch mode Human insight needed Program Infer Refactor code Annotated program Run type checker Add or remove qualifiers 15

16 Batch-mode tools make arbitrary decisions 16

17 17

18 BUG 18

19 Batch-mode tools make arbitrary decisions BUG 19

20 Type qualifier inference is a refactoring Adding type qualifiers preserves the program behavior Adding maintainable type qualifiers that match the programmer's intention requires code refactoring 20

21 Cascade: A Universal Programmer-assisted Type Qualifier Inference Tool Type Checker Cascade Type Inference 21

22 Cascade: A Universal Programmer-assisted Type Qualifier Inference Tool Compositional Refactoring Cascade Speculative Analysis 22

23 Inferring Primitive Changes from Error Messages Type Checker Error Nullness Fix incompatible types in argument. root = root.loadtree(q, xqic); ^ found MathVector MathVector 23

24 Inferring Primitive Changes from Error Messages Type Checker Error Nullness incompatible types in argument. root = root.loadtree(q, xqic); ^ found MathVector MathVector Fix Change parameter xpic of loadtree() MathVector 24

25 Inferring Primitive Changes from Error Messages Type Checker Error Nullness Mutability incompatible types in argument. root = root.loadtree(q, xqic); ^ found MathVector MathVector Fix Change parameter xpic of loadtree() MathVector call to value(int) not allowed on the given receiver. ic.value(k); ^ found MathVector MathVector 25

26 Inferring Primitive Changes from Error Messages Type Checker Error Nullness Mutability Fix incompatible types in argument. root = root.loadtree(q, xqic); ^ found MathVector MathVector Change parameter xpic of loadtree() MathVector call to value(int) not allowed on the given receiver. ic.value(k); ^ found MathVector MathVector Change receiver parameter of value() MathVector 26

27 Speculative analysis suggests a change composition 27

28 Speculative analysis suggests a change composition 28

29 Speculative analysis suggests a change composition 29

30 Speculative analysis suggests a change composition 30

31 Cascade Tree 31

32 Cascade Tree 32

33 Cascade Tree 33

34 34

35 35

36 36

37 The speculative analysis computes a tree recursively Program p e1 Error 37

38 The speculative analysis computes a tree recursively Program Fix p e1 c1 Error 38

39 The speculative analysis computes a tree recursively Program Fix p e1 c1(p) c1 e2 e3 Error 39

40 The speculative analysis computes a tree recursively Program Fix p e1 Error c1(p) c1 c2 e2 e3 c3 40

41 The speculative analysis computes a tree recursively Program Fix p e1 Error c2(c1(p)) c1(p) c1 c2 e3 e2 e3 c3(c1(p)) c3 e4 41

42 A change is represented as an AST path Primitive Change Variable Decl. Fixer Method Return Fixer Method Receiver Fixer Representation Compilation Unit + Variable Decl. + New Type Compilation Unit + Method Decl. + New Type Compilation Unit + Method Decl. + New Type 42

43 Research Questions How does Cascade compare with Julia, a batch qualifier inference tool? Learnability Quality of results Task completion time Control over process Willingness to use 43

44 User study Subjects: 12 computer science graduate students from 9 different research labs Familiar with Java and Eclipse Average of 10 years of programming experience 44

45 Training Nullness Checker Julia Cascade github.com/reprogrammer/tqi-study 45

46 Task Design Julia then Cascade Cascade then Julia MST then BH 3 participants 3 participants BH then MST 3 participants 3 participants BH Barnes-Hut, a hierarchical force-calculation algorithm MST Bentley s algorithm for finding the minimum spanning tree of a graph 46

47 Users complete tasks faster with Cascade t test p = 0.01 Cohen s d =

48 Users added less inaccurate annotations with Cascade BH + MST Julia Cascade Incorrect Redundant Unnecessary warning suppressions Correct 48

49 Postquestionnaire Results Questions (T = Julia or Cascade) I found T easy to learn. I know why T inserted each annotation. Using T, I have control over the process of annotating the code. I'm willing to use T in the Cascad Equal Julia e Rating better better

50 Qualitative Interview Results The participants believe that: Cascade's speculative analysis is useful (N = 8). Cascade is more predictable (N = 7). Cascade's tree computation is slow (N = 5). The overhead of fixing Julia's annotations is high (N = 7). 50

51 Future Work Improve the performance of Cascade. Evaluate compositional refactoring and Cascade in the field. Make Cascade support bidirectional speculative analysis. 51

52 Cascade: A Universal Type Qualifier Inference Tool Cascade is easy to use and helps users complete tasks fast. Compositional refactoring and speculative analysis. Less is sometimes more in the automation of software evolution tasks. More automation is not always better Some tasks need problem-solving and creativity Applicable to other fields 52