At codacy we don’t only rely on external tools to find code patterns.
Especially when it comes to Scala we also have a nice repository of homemade patterns. Therefore we need to be able to process Scala sourcecode. And by processing we mainly mean transforming source code into Abstract Syntax Trees (ASTs).
Everything you find here you can try yourself in the repl. Be sure to add the following sbt resolver and dependencies
(Not yet deprecated) scala.reflect
Up until now we used the standard scala.reflect.api and the toolbox it provides. To parse scala code with help of the reflection toolbox we need to run the following:
The resulting tree variable is of type toolbox.u.Tree and this is the structure we use(d) to find problematic code. That doesn’t look too complicated you might say. Well you are right but the problems start here. Unfortunately those Trees are very complex (after all they represent the complete AST of your program). Also documentation is kinda poor – as writer of patterns I had to rely mainly on Scaladoc and partly Reflection.
Sidenote: Real life .scala files usually reside in packages which means a typical sourcefile will start with package foo ... The current implementation of the toolbox however is not able to parse such files. We were forced to implement a workaround that preyed on my mind ever since.
All of this doesn’t really make it easy for someone who doesn’t know the internals of scala.reflect.api to start writing patterns from scratch. But that’s exactly what we want. We want to make it possible for our users to write custom patterns for their issues.
scala.meta to the rescue
Recently we started a very promising collaboration with Eugene Burmako and Mathieu Demarne from scala.meta. scala.meta was created to simplify metaprograming in scala and will hopefully be the successor of the current scala.reflect. For us it already is. Let’s try to get a scala.meta.Tree
And that’s it. (Now try parsing a proper .scala file containing a package definition – spoiler alert : it works! ) But that’s not all, in scala.meta.tql we find a neat tree query language that helps us writing patterns. Let’s try to implement a pattern that finds occurrence of try-catch blocks. (On codacy you can read why you shouldn’t use them)
We can now pass trees to the tryMatcher, let’s just try a simple test code:
Et voila – the repl doesn’t lie – “found culprit at line 0”
Stay tuned about the future of scala.meta at Codacy
The post A quick look at scala.meta appeared first on Codacy | Blog.