Using Scala for Xtext scope definitions
Over the last couple of days I have experimented with using Scala
for a XText scope
definitions. In my opinion, the current API for defining reference scopes in Xtext has two problems: first, because it is based on naming conventions, there is no compiler error if you change the name of the referencing feature; your scope definition simply isn't invoked anymore. The second problem is that Java is not necessarily the ideal language to write more or less complex model navigation and query code.
My Scala implementation addresses both of these problems. Scala, through its functional programming flavor, is much better suited for model navigation and query. Also, I've decided to generate a base class with empty scope definition methods and you provide the customized implementation in a subclass. Since Scala requires the use of the override
modifier if you want to override a method in a subclass, you get a compiler error if you change the name of the referencing feature (and hence, the name of the generated method in the base class).
In the rest of this post I explain how I built this, and also discuss my experiences, and whether I recommend using this approach or not.
The first you have to do is to install the Scala IDE for Eclipse
. Then you have to Scala-enable your language project, since you want to put scala code into it. I have described here
how you do this.
Then you need to make sure that the base class with the generated scope methods is generated as part of the language generation process. To do this, I have written a plug-in that contains an additional Xtext generator fragment
that generates this code. Generator fragments are plug-ins into the Xtext generator. You get the language grammar as an EMF model, and then you can generate whatever you want from it.
Based on this infrastructure, you can then implement your own scope in Scala.
Should you use this approach? In principle, yes. Scala really is much nicer than Java, particularly for the task at hand. And the fact that you get compiler errors if you rename properties is really useful.
However, in practice there are two problems that really make me recommend do not use this approach at this time
: the first one is that the EMF data structures don't play well with Scala's collection API. You have to write a lot of conversion functions. While this is in principle possible (and actually, quite nice to do due to Scala's implicit methods
) you do pay a performance penalty. However, I think this issue can be solved.
The second problem is the Scala IDE for Eclipse. At least in this scenario, where you mix Java and Scala code, and where you use it for plug-in development, the IDE really is not good enough. For example, code completion doesn't work (at least on my machine), you have to do a full rebuild constantly to make sure changes in the Scala code make it to the class files, a compiler error in the Scala file "destroys" the classpath, preventing Xtext from generating the language, there is no "organize imports" for Scala, etc. etc.
Now, my goal here is not at all to bash the Scala IDE. I got good support from Miles Sabin
who is the main person behind it. He said that by the end of the year the Scala IDE should be roughly comparable to the Java IDE in Eclipse (and he's looking for help in reaching this goal!). So I guess, I will check back later, when the 2.8 release of the IDE is available. I really think, once the Scala tooling in Eclipse has matured, using Scala for scopes is a good idea.