Extending Type Inference to Variational Programs

Abstract

Through the use of conditional compilation and related tools, many software projects can be used to generate a huge number of related programs. The problem of typing such variational software is difficult. The brute-force strategy of generating all variants and typing each one individually is: (1) usually infeasible for efficiency reasons and (2) produces results that do not map well to the underlying variational program. Recent research has focused mainly on efficiency and addressed only the problem of type checking. In this work we tackle the more general problem of variational type inference and introduce variational types to represent the result of typing a variational program. We introduce the variational lambda calculus (VLC) as a formal foundation for research on typing variational programs. We define a type system for VLC in which VLC expressions are mapped to correspondingly variational types. We show that the type system is correct by proving that the typing of expressions is preserved over the process of variation elimination, which eventually results in a plain lambda calculus expression and its corresponding type. We identify a set of equivalence rules for variational types and prove that the type unification problem modulo these equivalence rules is unitary and decidable; we also present a sound and complete unification algorithm. Based on the unification algorithm, the variational type inference algorithm is an extension of algorithm W . We show that it is sound and complete and computes principal types. We also consider the extension of VLC with sum types, a necessary feature for supporting variational data types, and demonstrate that the previous theoretical results also hold under this extension. Finally, we characterize the complexity of variational type inference and demonstrate the efficiency gains over the brute-force strategy.

Exploring variability-aware execution for testing plugin-based web applications

“…If a variable does not have a previous value, we use a special UNSET symbol as in a regular PHP interpreter to indicate that the variable is uninitialized in some configurations. Helper function createChoice performs some simplifications of the representation (lines [11][12][13][14][15][16][17][18][19][20][21][22]. Second, loading a variable's value in a given context φ (lines 7-10) is done by finding values in the variable's MultiValue that satisfy context φ via function extract (lines [24][25][26][27][28][29][30][31][32].…”

“…Variability-aware execution has been inspired by recent work on static analysis of product lines [26,51,51,33,40,16,15,23,21]. A community of researchers has investigated how to perform type checking [33,40,21,51], model checking [23,39], data-flow analysis [16,15,40], and other analyses [26,34] on multiple compile-time configurations of a system at a time. This community has explored how to represent and reason about partial but finite configuration spaces compactly with BDDs or SAT solvers (as used in our variability contexts) [14,33,41], how to represent choices of structures [28] and in complex structures [29,40].…”

A Classification and Survey of Analysis Strategies for Software Product Lines

“…The rules of these type systems contain reachability checks (basically implications) making sure, among others, that every program element is defined in all products where it is referenced. Variability-aware type systems have been developed for composition-based implementation [Thaker et al 2007;Huang et al 2007;Kim et al 2008;Kuhlemann et al 2009;Delaware et al 2009;Apel et al 2010a;Apel et al 2010c;Kolesnikov et al 2013], composition-based design [Alférez et al 2011], annotation-based implementation [Aversano et al 2002;Kim et al 2008;Kenner et al 2010;Teixeira et al 2011;Kästner et al 2012a;Kästner et al 2012b;Liebig et al 2013;Le et al 2013;Chen et al 2014], and annotation-based design [Czarnecki and Pietroszek 2006;Metzger et al 2007;Heidenreich 2009]. For composition-based product lines, type checking ensures safe composition [Thaker et al 2007;Kim et al 2008].…”

“…However, when dealing with implicitly-typed languages, instead of only checking whether a term is of a given type, we also need to infer types for given terms. A type system that performs type inference for an extension of the lambda calculus has been presented by Chen et al [2014].…”

“…First, we found that, in almost all studies, a particular strategy is compared to an unoptimized product-based analysis Schaefer et al 2010;Cordy et al 2012a;Cordy et al 2012c;Sabouri and Khosravi 2012;Greenyer et al 2013;Apel et al 2013c;Classen et al 2013;Sabouri and Khosravi 2013a;Classen et al 2013;Sabouri and Khosravi 2013b;Classen et al 2014;Chen et al 2014] or to the analysis of a single product [Post and Sinz 2008;Delaware et al 2009;Kenner et al 2010;Kästner et al 2011;Kästner et al 2012a;Gazzillo and Grimm 2012]. The advantage of such a standard evaluation is that we can compare different approaches more easily; even if evaluations strongly depend on the size and kind of product line being analyzed.…”