org.scalameta:mtags module that supports rendering scala/java docstrings into markdown given a SemanticDB symbol. We use mtags in Metals to power goto definition indexes and displaying docstrings in completion results + type at point
Is it possible to do this with scalameta?
class MyMonad[T](value: T) {
def map: Nothing = ???
def flatMap: Nothing = ???
// .....
// Automatically generated code?
}
object MyMonadThing {
implicit def tToMyMonadThingT[T](value: T): MyMonad[T] =
new MyMonad[T](value)
}
object Usage {
import MyMonadThing._
val res0: Int = 5 + 5
val res1: MyMonad[Int] = 5 + 5
val res2: MyMonad[Int] = res1 + res0
}Where it would be able to figure out that:
res0 + res1
// should really be:
res1.map(_ + res0)
@captify-osoldatov
https://stackoverflow.com/questions/61796570/scala-conditional-compilation/
https://stackoverflow.com/questions/35338239/macro-annotation-to-override-tostring-of-scala-function/
https://stackoverflow.com/questions/58562229/how-to-merge-multiple-imports-in-scala/
Define the following project/Transformer.scala
import scala.meta._
object Transformer {
def transform(input: String): String = {
transform(input.parse[Source].get).syntax
}
def transform(tree: Tree): Tree = {
tree.transform {
case q"""..$mods class $tname[..$tparams] ..$ctorMods (...$paramss) extends ${
template"{ ..$stats } with ..$inits { $self => ..$stats1 }"
}""" if inits.collect { case t@init"SomeClass" => t }.nonEmpty =>
q"""..$mods class $tname[..$tparams] ..$ctorMods (...$paramss) extends ${
template"""{ ..$stats } with ..$inits { $self =>
def foo(): Unit = ()
..$stats1
}"""}"""
case q"""..$mods object $ename extends ${
template"{ ..$stats } with ..$inits { $self => ..$stats1 }"
}""" if inits.collect { case t@init"SomeClass" => t }.nonEmpty =>
q"""..$mods object $ename extends ${
template"""{ ..$stats } with ..$inits { $self =>
def foo(): Unit = ()
..$stats1
}"""
}"""
}
}
}This adds def foo(): Unit = () to every class or object extending SomeClass.
Hi! I'm completely new to scalamet and trying to transform or traverce a code source file to get the class/trait/def structure in xml.
I've tried the both transform and traverse but can't get what I want - the set of nested <node> tags corresponding to the structure.
Here is one of my attempt which partly works - produces the file containing the definition lines but since I can't call this recursively I can't get the nested <node> </node>tags. I've also tried
def customTransformer1(filename:String) = {
val file = new File(filename)
val bw = new BufferedWriter(new FileWriter(file))
val x = this.exampleTree2.transform {
case source"..$stats" => {bw.write("source" +"\n")
source"..$stats"
}
case q"package $eref { ..$stats }" => {bw.write("Pkg "+eref+"\n")
q"package $eref { ..$stats }"
}
case q"..$mods class $tname[..$tparams] ..$ctorMods (...$paramss) extends $template" => {
bw.write("class "+tname+"\n")
q"..$mods class $tname[..$tparams] ..$ctorMods (...$paramss) extends $template"
}
case q"..$mods trait $tname[..$tparams] extends $template" => {
bw.write("trait "+tname+"\n")
q"..$mods trait $tname[..$tparams] extends $template"
}
case q"..$mods def $ename[..$tparams](...$paramss): $tpeopt = $expr" =>{
bw.write("def "+ename+paramss+"\n")
q"..$mods def $ename[..$tparams](...$paramss): $tpeopt = $expr"
}
}.toString()
bw.close()}
I've also tried to write custom transform/traverse with
super.apply(node)
but can't get it work
Any help would be higly appretiated.
Thank you in advance.
Traverser? https://scalameta.org/docs/trees/guide.html#custom-traversals
Thank you for the answer! Trying to reproduce my problem with Traverser I occassionally got the result which I wanted. Here is my code and now there are just some little questions (below the code)
def customTravers2(filename:String) = {
val file = new File(filename)
val bw = new BufferedWriter(new FileWriter(file))
val traverser = new Traverser {
override def apply(tree: Tree): Unit = {
tree match {
case source"..$stats" => {
bw.write("<node>"+ "\n")
bw.write(s"source " + "\n")
super.apply(stats(0))
bw.write("</node>"+ "\n")
}
case q"package $eref { ..$stats }" => {
bw.write("<node>"+ "\n")
bw.write(s"package $eref" + "\n")
super.apply(stats(0))
bw.write("</node>"+ "\n")
}
case q"..$mods class $tname[..$tparams] ..$ctorMods (...$paramss) extends $template" => {
bw.write("<node>"+ "\n")
bw.write(s"class $tname $paramss" + "\n")
super.apply(template)
bw.write("</node>"+ "\n")
}
case q"..$mods object $ename extends $template" => {
bw.write("<node>"+ "\n")
bw.write(s"object $ename" + "\n")
super.apply(template)
bw.write("</node>"+ "\n")
}
case q"..$mods trait $tname[..$tparams] extends $template" => {
bw.write("<node>"+ "\n")
bw.write( s"trait $tname" + "\n")
super.apply(template)
bw.write("</node>"+ "\n")
}
case q"..$mods def $ename[..$tparams](...$paramss): $tpeopt = $expr" => {
bw.write("<node>"+ "\n")
bw.write( s"def $ename $paramss" + "\n")
super.apply(expr)
bw.write("</node>"+ "\n")
}
case node => {}
}
}
}
traverser(exampleTree2)
bw.close()}
This code produces (almost what I want)
<node>
source
<node>
class User List(List(id: String="", email: String, firstName: String, lastName: String, password:String, agreem:Boolean=false, activationStatus:Int=0, acode:String=""))
<node>
def activate List(List(acodeFromRequest: String))
</node>
<node>
def update List(List(userNewData: UserEditData))
</node>
</node>
<node>
object User
<node>
def apply List(List(email: String, firstName: String, lastName: String, password:String, agreem:Boolean, activationStatus:Int, acode:String))
</node>
<node>
def findAll List()
</node>
<node>
def findById List(List(id:Int))
</node>
<node>
def findByACode List(List(acode:String))
</node>
<node>
def findByEmail List(List(email:String))
</node>
<node>
def generateACode List(List(email:String, lastName:String))
</node>
<node>
def emailServerIsValid List(List(s: String))
</node>
<node>
def charsAreAllowedInNames List(List(s: String))
</node>
<node>
def encryptPassword List(List(pwd:String))
</node>
<node>
def passwordIsCorrect List(List(email:String, password: String))
</node>
</node>
</node>
So here are the questions:
1) The code line " case node => {}" produces nothing but this doesn't work whithout it. Why do we need such the line?
2) Am I right using " super.apply(stats(0))" specifically stats(0) to get nested nodes for some nodes. It looks not well unified....
3) I get list of args as "List(List(userNewData: UserEditData))". How can I correctly get just the inner part : "(userNewData: UserEditData)"?
scala.meta._ and would like to add comments so the scaladoc for the generated code will be useful. My current plan is to toString the trees and do regex search/replace on the string to insert comments as a second pass, which seems awful. Hoping I'm missing something obvious.
+ to 1 thing. Im saying that for anything, it could look inside whatever it is wrapped in, and enact map/flatMap on it. +, -, firstName, toCharArray, anything...
MyMonad[Int] and MyMonad[String] should have different sets of methods (in Scala/Java generic classes are compiled once on contrary to templates in C++ compiled for every type parameter). So it seems you're looking for scala.Dynamic class MyMonad[T](val value: T) extends Dynamic {
// ...
def applyDynamic(method: String)(args: Any*): Any = macro MyMonadMacro.applyDynamicImpl
}
object MyMonadMacro {
def applyDynamicImpl(c: whitebox.Context)(method: c.Tree)(args: c.Tree*): c.Tree = {
import c.universe._
val q"${methodName: String}" = method
q"${c.prefix}.value.${TermName(methodName).encodedName.toTermName}(..$args)"
}
}
import Predef.{any2stringadd => _}
import MyMonadThing._
val res0: Int = 5 + 5
val res1: MyMonad[Int] = 5 + 5
val res2: MyMonad[Int] = res1 + res0 // compilesargs should be Any because methods of T can accept arguments of arbitrary types. Any in return type is not actually Any but some subtype of Any (because the macro is whitebox). res1 + res0 has type Int and not Any(that's why implicit conversion Int => MyMonad[Int] works, otherwise if the macro were blackbox then for Any it wouldn't because there is no implicit conversion Any => MyMonad[Int]).
import klib.dynamic._
import klib.fp.ops._
object Test {
case class Person(var firstName: String, var lastName: String, var age: Int) {
def asStr(f: Person => String): String =
f(this)
}
def main(args: Array[String]): Unit = {
val person: ??[Person] = Person("First-1", "Last-1", 1).lift[??]
println(person.firstName)
println(person.lastName)
println(person.age)
person.firstName = "First"
person.lastName = "Last"
person.age = 2
println(person)
println(person.asStr((p: Person) => s"${p.lastName}, ${p.firstName}"))
// Everything above this line is working how I would hope
val _4: ??[Int] = person.age + person.age
}
}person.firstName translates to person.map(_.firstName), but what I would also like is:person.age + person.age
// translates to:
person.flatMap { p1 =>
person.map { p2 =>
p1 + p2
}
}Person doesn't have explicit method firstName so compiler starts to look for it via implicits and dynamics. But Int already has explicit method + so compiler won't look for it via implcits and dynamics. person.age + person.age is just a sum of two Ints which don't remember that they were person.age. So now you want to work with them as ASTs. Rewriting one tree to another wouldn't be difficult with Scalameta but detecting when such rewriting should be applied can be harder (person.age + person.age should be rewritten but 1 + 1 shouldn't). I guess one would need a compiler plugin.