Xoc, an extension-oriented compiler for systems programming

Syntactic language extensions can introduce new facilities into a programming language while requiring little implementation effort and modest changes to the compiler. It is typical to desugar language extensions in a distinguished compiler phase after parsing or type checking, not affecting any of the later compiler phases. If desugaring happens before type checking, the desugaring cannot depend on typing information and type errors are reported in terms of the generated code. If desugaring happens after type checking, the code generated by the desugaring is not type checked and may introduce vulnerabilities. Both options are undesirable. We propose a system for syntactic extensibility where desugaring happens after type checking and desugarings are guaranteed to only generate well-typed code. A major novelty of our work is that desugarings operate on typing derivations instead of plain syntax trees. This provides desugarings access to typing information and forms the basis for the soundness guarantee we provide, namely that a desugaring generates a valid typing derivation. We have implemented our system for syntactic extensibility in a languageindependent fashion and instantiated it for a substantial subset of Java, including generics and inheritance. We provide a sound Java extension for Scala-like for-comprehensions.

show abstract

“…TemplateHaskell [26], Camlp4 [5], MetaHaskell [20], Ziggurat [9] Xoc [4], Scala macros [1], TSLs in Wyvern [23] static soundness…”

Section: Dynamic Soundnessmentioning

confidence: 99%

Sound type-dependent syntactic language extension

LorenzenFlorian

ErdwegSebastian

2016

SIGPLAN Not.

View full text Add to dashboard Cite

show abstract

“…Language-external mechanisms for creating and combining language dialects, e.g. extensible compilers like Xoc [17], JastAdd [24], Polyglot [50], JaCo [76], Silver [72] and various language workbenches [26], do not guarantee determinism. In particular, these systems presume that new language constructs define new textual forms.…”

Section: Related Workmentioning

confidence: 99%

Programmable semantic fragments: the design and implementation of typy

Omar

Aldrich

2016

Proceedings of the 2016 ACM SIGPLAN International Conference on Generative Programming: Concepts and Experiences

View full text Add to dashboard Cite

This paper introduces typy, a statically typed programming language embedded by reflection into Python. typy features a fragmentary semantics, i.e. it delegates semantic control over each term, drawn from Python's fixed concrete and abstract syntax, to some contextually relevant user-defined semantic fragment. The delegated fragment programmatically 1) typechecks the term (following a bidirectional protocol); and 2) assigns dynamic meaning to the term by computing a translation to Python. We argue that this design is expressive with examples of fragments that express the static and dynamic semantics of 1) functional records; 2) labeled sums (with nested pattern matching a la ML); 3) a variation on JavaScript's prototypal object system; and 4) typed foreign interfaces to Python and OpenCL. These semantic structures are, or would need to be, defined primitively in conventionally structured languages. We further argue that this design is compositionally wellbehaved. It avoids the expression problem and the problems of grammar composition because the syntax is fixed. Moreover, programs are semantically stable under fragment composition (i.e. defining a new fragment will not change the meaning of existing program components.

show abstract

“…Some systems such as SugarJ [11], ometa [37], Xtc [18], Xoc [8], and Polyglot [26] provide extensible grammars but require the programmer to reason about parser details. Multi stage systems such as mython [31] and MetaML [25,34] can also be used to create macros systems like MacroML [16].…”

Section: Related Workmentioning

confidence: 99%

Sweeten your JavaScript

et al. 2014

View full text Add to dashboard Cite

Lisp and Scheme have demonstrated the power of macros to enable programmers to evolve and craft languages. In languages with more complex syntax, macros have had less success. In part, this has been due to the difficulty in building expressive hygienic macro systems for such languages. JavaScript in particular presents unique challenges for macro systems due to ambiguities in the lexing stage that force the JavaScript lexer and parser to be intertwined. In this paper we present a novel solution to the lexing ambiguity of JavaScript that enables us to cleanly separate the JavaScript lexer and parser by recording enough history during lexing to resolve ambiguities. We give an algorithm for this solution along with a proof that it does in fact correctly resolve ambiguities in the language. Though the algorithm and proof we present is specific to JavaScript, the general technique can be applied to other languages with ambiguous grammars. With lexer and parser separated, we then implement an expressive hygienic macro system for JavaScript called sweet.js.

show abstract

Xoc, an extension-oriented compiler for systems programming

Cited by 5 publications

References 25 publications

Sound type-dependent syntactic language extension

Sound type-dependent syntactic language extension

Programmable semantic fragments: the design and implementation of typy

Sweeten your JavaScript

Contact Info

Product

Resources

About