CFAAR: Control Flow Alteration to Assist Repair

We present CFAAR, a program repair assistance technique that operates by selectively altering the outcome of suspicious predicates in order to yield expected behavior. CFAAR is applicable to defects that are repairable by negating predicates under specific conditions. CFAAR proceeds as follows: 1) it identifies predicates such that negating them at given instances would make the failing tests exhibit correct behavior; 2) for each candidate predicate, it uses the program state information to build a classifier that dictates when the predicate should be negated; 3) for each classifier, it leverages a Decision Tree to synthesize a patch to be presented to the developer. We evaluated our toolset using 149 defects from the IntroClass and Siemens benchmarks. CFAAR identified 91 potential candidate defects and generated plausible patches for 41 of them. Twelve of the patches are believed to be correct, whereas the rest provide repair assistance to the developer.

💡 Research Summary

The paper introduces CFAAR (Control Flow Alteration to Assist Repair), a test‑based program repair assistance technique that focuses on defects that can be fixed by negating the outcome of a predicate under specific runtime conditions. The approach proceeds in four main steps. First, a coverage‑based fault localisation (CBFL) component identifies a set of suspicious predicates; in the experiments all predicates are treated as suspicious due to the small size of the programs. Second, a heuristic search (HeuristicCFASearch) examines each predicate with a predefined set of execution patterns (e.g., always negate, negate only the first execution, negate all except the last, etc.) and determines whether applying a particular pattern makes any failing test pass. Successful (predicate, pattern) pairs become candidates for repair.

Third, for each candidate the system collects program state at the point of predicate execution. The state includes local variables, static fields, method parameters, and object attributes. Values are encoded as scalars for numeric types, categorical values for integral types, hash‑based categorical representations for strings, and recursive hash codes for non‑string objects. Each execution instance is labeled “negate” or “do not negate” according to whether the pattern required a change. These labeled vectors are used to train a decision‑tree classifier that predicts, based on the current state, whether the predicate should be flipped.

Finally, the learned decision tree is transformed into a Boolean expression in disjunctive normal form, which is then compiled into bytecode that guards the original predicate with an if‑statement. The resulting patch has the form: if (learnedCondition) then use the negated predicate else use the original one. Developers may adopt the patch directly if it is correct, or use it as a debugging hint.

The authors evaluated CFAAR on 149 single‑fault versions drawn from the IntroClass and Siemens benchmarks (57 Siemens, 91 IntroClass). HeuristicCFASearch identified 91 defects (≈61 %) as potentially repairable by predicate negation. From these, CFAAR synthesized plausible patches for 41 defects (≈28 % of the total). Manual inspection confirmed that 12 of the generated patches are indeed correct; the remaining patches are considered repair assistance rather than full fixes.

Key contributions include: (1) a novel focus on control‑flow alteration via predicate negation, (2) a pipeline that couples heuristic pattern search with state‑based machine learning, and (3) an automated synthesis of human‑readable conditional patches. The study shows that a substantial fraction of simple bugs can be addressed by this technique, while also highlighting limitations such as the need for more precise fault localisation, richer state representations for complex objects, and scalability to larger code bases. Future work is suggested in improving CBFL accuracy, extending the pattern space, and integrating more sophisticated feature extraction to enhance classifier quality. Overall, CFAAR demonstrates that targeted control‑flow manipulation, guided by learned runtime conditions, can be an effective and practical aid in the software debugging and repair process.