Merge remote-tracking branch 'scalamacros/pullrequest/macros' into develop

34 files changed, 242 insertions, 31 deletions

diff --git a/src/compiler/scala/tools/nsc/interpreter/MemberHandlers.scala b/src/compiler/scala/tools/nsc/interpreter/MemberHandlers.scala
index c742ab89c0..48a5fa9e34 100644
--- a/src/compiler/scala/tools/nsc/interpreter/MemberHandlers.scala
+++ b/src/compiler/scala/tools/nsc/interpreter/MemberHandlers.scala
@@ -118,8 +118,9 @@ trait MemberHandlers {
 
   class DefHandler(member: DefDef) extends MemberDefHandler(member) {
     private def vparamss = member.vparamss
-    // true if 0-arity
-    override def definesValue = vparamss.isEmpty || vparamss.head.isEmpty
+    private def isMacro = member.mods.hasFlag(scala.reflect.internal.Flags.MACRO)
+    // true if not a macro and 0-arity
+    override def definesValue = !isMacro && (vparamss.isEmpty || vparamss.head.isEmpty)
     override def resultExtractionCode(req: Request) =
       if (mods.isPublic) codegenln(name, ": ", req.typeOf(name)) else ""
   }
diff --git a/src/compiler/scala/tools/nsc/typechecker/ContextErrors.scala b/src/compiler/scala/tools/nsc/typechecker/ContextErrors.scala
index 6ee09d064f..09eb504186 100644
--- a/src/compiler/scala/tools/nsc/typechecker/ContextErrors.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/ContextErrors.scala
@@ -636,11 +636,6 @@ trait ContextErrors {
 
      def CyclicReferenceError(errPos: Position, lockedSym: Symbol) =
        issueTypeError(PosAndMsgTypeError(errPos, "illegal cyclic reference involving " + lockedSym))
-       
-     def MacroExpandError(tree: Tree, t: Any) = { 
-       issueNormalTypeError(tree, "macros must return a compiler-specific tree; returned class is: " + t.getClass)
-       setError(tree)
-     }
     }
   }
 
diff --git a/src/compiler/scala/tools/nsc/typechecker/Macros.scala b/src/compiler/scala/tools/nsc/typechecker/Macros.scala
index 470f3e7117..161e4b7a9a 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Macros.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Macros.scala
@@ -90,8 +90,19 @@ trait Macros { self: Analyzer =>
 
   lazy val mirror = new scala.reflect.runtime.Mirror {
     lazy val libraryClassLoader = {
+      // todo. this is more or less okay, but not completely correct
+      // see https://issues.scala-lang.org/browse/SI-5433 for more info
       val classpath = global.classPath.asURLs
-      ScalaClassLoader.fromURLs(classpath, self.getClass.getClassLoader)
+      var loader: ClassLoader = ScalaClassLoader.fromURLs(classpath, self.getClass.getClassLoader)
+
+      // an heuristic to detect REPL
+      if (global.settings.exposeEmptyPackage.value) {
+        import scala.tools.nsc.interpreter._
+        val virtualDirectory = global.settings.outputDirs.getSingleOutput.get
+        loader = new AbstractFileClassLoader(virtualDirectory, loader) {}
+      }
+
+      loader
     }
 
     override def defaultReflectiveClassLoader() = libraryClassLoader
@@ -112,19 +123,42 @@ trait Macros { self: Analyzer =>
 
       if (mmeth == NoSymbol) None
       else {
-        val receiverClass: mirror.Symbol = mirror.symbolForName(mmeth.owner.fullName)
+        trace("loading implementation class: ")(mmeth.owner.fullName)
+        trace("classloader is: ")("%s of type %s".format(mirror.libraryClassLoader, mirror.libraryClassLoader.getClass))
+        def inferClasspath(cl: ClassLoader) = cl match {
+          case cl: java.net.URLClassLoader => "[" + (cl.getURLs mkString ",") + "]"
+          case _ => "<unknown>"
+        }
+        trace("classpath is: ")(inferClasspath(mirror.libraryClassLoader))
+
+        // @xeno.by: relies on the fact that macros can only be defined in static classes
+        def classfile(sym: Symbol): String = {
+          def recur(sym: Symbol): String = sym match {
+            case sym if sym.owner.isPackageClass =>
+              val suffix = if (sym.isModuleClass) "$" else ""
+              sym.fullName + suffix
+            case sym =>
+              val separator = if (sym.owner.isModuleClass) "" else "$"
+              recur(sym.owner) + separator + sym.javaSimpleName
+          }
+
+          if (sym.isClass || sym.isModule) recur(sym)
+          else recur(sym.enclClass)
+        }
+
+        // @xeno.by: this doesn't work for inner classes
+        // neither does mmeth.owner.javaClassName, so I had to roll my own implementation
+        //val receiverName = mmeth.owner.fullName
+        val receiverName = classfile(mmeth.owner)
+        val receiverClass: mirror.Symbol = mirror.symbolForName(receiverName)
+
         if (debug) {
           println("receiverClass is: " + receiverClass.fullNameString)
 
           val jreceiverClass = mirror.classToJava(receiverClass)
           val jreceiverSource = jreceiverClass.getProtectionDomain.getCodeSource
           println("jreceiverClass is %s from %s".format(jreceiverClass, jreceiverSource))
-
-          val jreceiverClasspath = jreceiverClass.getClassLoader match {
-            case cl: java.net.URLClassLoader => "[" + (cl.getURLs mkString ",") + "]"
-            case _ => "<unknown>"
-          }
-          println("jreceiverClassLoader is %s with classpath %s".format(jreceiverClass.getClassLoader, jreceiverClasspath))
+          println("jreceiverClassLoader is %s with classpath %s".format(jreceiverClass.getClassLoader, inferClasspath(jreceiverClass.getClassLoader)))
         }
 
         val receiverObj = receiverClass.companionModule
@@ -132,7 +166,11 @@ trait Macros { self: Analyzer =>
 
         if (receiverObj == mirror.NoSymbol) None
         else {
-          val receiver = mirror.companionInstance(receiverClass)
+          // @xeno.by: yet another reflection method that doesn't work for inner classes
+          //val receiver = mirror.companionInstance(receiverClass)
+          val clazz = java.lang.Class.forName(receiverName, true, mirror.libraryClassLoader)
+          val receiver = clazz getField "MODULE$" get null
+
           val rmeth = receiverObj.info.member(mirror.newTermName(mmeth.name.toString))
           if (debug) {
             println("rmeth is: " + rmeth.fullNameString)
@@ -147,6 +185,7 @@ trait Macros { self: Analyzer =>
       }
     } catch {
       case ex: ClassNotFoundException =>
+        trace("implementation class failed to load: ")(ex.toString)
         None
     }
   }
@@ -155,7 +194,7 @@ trait Macros { self: Analyzer =>
    *  Or, if that fails, and the macro overrides a method return
    *  tree that calls this method instead of the macro.
    */
-  def macroExpand(tree: Tree, context: Context): Option[Any] = {
+  def macroExpand(tree: Tree, typer: Typer): Option[Any] = {
     val trace = scala.tools.nsc.util.trace when settings.Ymacrodebug.value
     trace("macroExpand: ")(tree)
 
@@ -180,7 +219,19 @@ trait Macros { self: Analyzer =>
           // if one of those children involves macro expansion, things might get nasty
           // that's why I'm temporarily turning this behavior off
           nodePrinters.infolevel = nodePrinters.InfoLevel.Quiet
-          Some(mirror.invoke(receiver, rmeth)(rawArgs: _*))
+          val expanded = mirror.invoke(receiver, rmeth)(rawArgs: _*)
+          expanded match {
+            case expanded: Tree =>
+              val expectedTpe = tree.tpe
+              val typed = typer.typed(expanded, EXPRmode, expectedTpe)
+              Some(typed)
+            case expanded if expanded.isInstanceOf[Tree] =>
+              typer.context.unit.error(tree.pos, "macro must return a compiler-specific tree; returned value is Tree, but it doesn't belong to this compiler's universe")
+              None
+            case expanded =>
+              typer.context.unit.error(tree.pos, "macro must return a compiler-specific tree; returned value is of class: " + expanded.getClass)
+              None
+          }
         } catch {
           case ex =>
             val realex = ReflectionUtils.unwrapThrowable(ex)
@@ -191,14 +242,14 @@ trait Macros { self: Analyzer =>
             } else {
               realex.getMessage
             }
-            context.unit.error(tree.pos, "exception during macro expansion: " + msg)
+            typer.context.unit.error(tree.pos, "exception during macro expansion: " + msg)
             None
         } finally {
           nodePrinters.infolevel = savedInfolevel
         }
       case None =>
         def notFound() = {
-          context.unit.error(tree.pos, "macro implementation not found: " + macroDef.name)
+          typer.context.unit.error(tree.pos, "macro implementation not found: " + macroDef.name)
           None
         }
         def fallBackToOverridden(tree: Tree): Option[Tree] = {
diff --git a/src/compiler/scala/tools/nsc/typechecker/Typers.scala b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
index e7cd139ce0..17c0bdf304 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Typers.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
@@ -941,10 +941,14 @@ trait Typers extends Modes with Adaptations with PatMatVirtualiser {
           }
           if (tree.isType)
             adaptType()
-          else if (inExprModeButNot(mode, FUNmode) && tree.symbol != null && tree.symbol.isMacro && !tree.isDef) {
-            val tree1 = expandMacro(tree)
-            if (tree1.isErroneous) tree1 else typed(tree1, mode, pt) 
-          } else if ((mode & (PATTERNmode | FUNmode)) == (PATTERNmode | FUNmode))
+          else if (inExprModeButNot(mode, FUNmode) && tree.symbol != null && tree.symbol.isMacro && !tree.isDef && !(tree exists (_.isErroneous)))
+            macroExpand(tree, this) match {
+              case Some(expanded: Tree) =>
+                typed(expanded, mode, pt)
+              case None =>
+                setError(tree) // error already reported
+            }
+          else if ((mode & (PATTERNmode | FUNmode)) == (PATTERNmode | FUNmode))
             adaptConstrPattern()
           else if (inAllModes(mode, EXPRmode | FUNmode) &&
             !tree.tpe.isInstanceOf[MethodType] &&
@@ -4545,13 +4549,6 @@ trait Typers extends Modes with Adaptations with PatMatVirtualiser {
       }
     }
 
-    def expandMacro(tree: Tree): Tree =
-      macroExpand(tree, context) match {
-        case Some(t: Tree) => t
-        case Some(t)       => MacroExpandError(tree, t)
-        case None          => setError(tree) // error already reported
-      }
-
     def atOwner(owner: Symbol): Typer =
       newTyper(context.make(context.tree, owner))
 
diff --git a/test/files/neg/macro-argtype-mismatch.check b/test/files/neg/macro-argtype-mismatch.check
new file mode 100644
index 0000000000..dd867be804
--- /dev/null
+++ b/test/files/neg/macro-argtype-mismatch.check
@@ -0,0 +1,6 @@
+Test_2.scala:3: error: type mismatch;

+ found   : String("2")

+ required: Int

+  foo("2")

+      ^

+one error found

diff --git a/test/files/neg/macro-argtype-mismatch.flags b/test/files/neg/macro-argtype-mismatch.flags
new file mode 100644
index 0000000000..7fea2ff901
--- /dev/null
+++ b/test/files/neg/macro-argtype-mismatch.flags
@@ -0,0 +1 @@
+-Xmacros
\ No newline at end of file
diff --git a/test/files/neg/macro-argtype-mismatch/Macros_1.scala b/test/files/neg/macro-argtype-mismatch/Macros_1.scala
new file mode 100644
index 0000000000..4b5f98ba37
--- /dev/null
+++ b/test/files/neg/macro-argtype-mismatch/Macros_1.scala
@@ -0,0 +1,3 @@
+object Macros {
+  def macro foo(x: Int) = x
+}
\ No newline at end of file
diff --git a/test/files/neg/macro-argtype-mismatch/Test_2.scala b/test/files/neg/macro-argtype-mismatch/Test_2.scala
new file mode 100644
index 0000000000..18feb69425
--- /dev/null
+++ b/test/files/neg/macro-argtype-mismatch/Test_2.scala
@@ -0,0 +1,4 @@
+object Test extends App {
+  import Macros._
+  foo("2")
+}
\ No newline at end of file
diff --git a/test/files/neg/macro-noexpand.check b/test/files/neg/macro-noexpand.check
new file mode 100644
index 0000000000..c15d54bb32
--- /dev/null
+++ b/test/files/neg/macro-noexpand.check
@@ -0,0 +1,4 @@
+Test_2.scala:3: error: not found: value x

+  foo(x)

+      ^

+one error found

diff --git a/test/files/neg/macro-noexpand.flags b/test/files/neg/macro-noexpand.flags
new file mode 100644
index 0000000000..7fea2ff901
--- /dev/null
+++ b/test/files/neg/macro-noexpand.flags
@@ -0,0 +1 @@
+-Xmacros
\ No newline at end of file
diff --git a/test/files/neg/macro-noexpand/Macros_1.scala b/test/files/neg/macro-noexpand/Macros_1.scala
new file mode 100644
index 0000000000..7a6aadf6a1
--- /dev/null
+++ b/test/files/neg/macro-noexpand/Macros_1.scala
@@ -0,0 +1,3 @@
+object Macros {
+  def macro foo(x: Any) = ???
+}
\ No newline at end of file
diff --git a/test/files/neg/macro-noexpand/Test_2.scala b/test/files/neg/macro-noexpand/Test_2.scala
new file mode 100644
index 0000000000..0bed592883
--- /dev/null
+++ b/test/files/neg/macro-noexpand/Test_2.scala
@@ -0,0 +1,4 @@
+object Test extends App {
+  import Macros._
+  foo(x)
+}
\ No newline at end of file
diff --git a/test/files/neg/macro-noncompilertree.check b/test/files/neg/macro-noncompilertree.check
new file mode 100644
index 0000000000..616765a39e
--- /dev/null
+++ b/test/files/neg/macro-noncompilertree.check
@@ -0,0 +1,6 @@
+Macros_1.scala:2: error: type mismatch;

+ found   : reflect.mirror.Literal

+ required: _context.Tree

+  def macro foo = scala.reflect.mirror.Literal(scala.reflect.mirror.Constant(2))

+                                              ^

+one error found

diff --git a/test/files/neg/macro-noncompilertree.flags b/test/files/neg/macro-noncompilertree.flags
new file mode 100644
index 0000000000..7fea2ff901
--- /dev/null
+++ b/test/files/neg/macro-noncompilertree.flags
@@ -0,0 +1 @@
+-Xmacros
\ No newline at end of file
diff --git a/test/files/neg/macro-noncompilertree/Macros_1.scala b/test/files/neg/macro-noncompilertree/Macros_1.scala
new file mode 100644
index 0000000000..eb1253e5e9
--- /dev/null
+++ b/test/files/neg/macro-noncompilertree/Macros_1.scala
@@ -0,0 +1,3 @@
+object Macros {
+  def macro foo = scala.reflect.mirror.Literal(scala.reflect.mirror.Constant(2))
+}
\ No newline at end of file
diff --git a/test/files/neg/macro-nontree.check b/test/files/neg/macro-nontree.check
new file mode 100644
index 0000000000..a1c7139580
--- /dev/null
+++ b/test/files/neg/macro-nontree.check
@@ -0,0 +1,6 @@
+Macros_1.scala:2: error: type mismatch;

+ found   : Int(2)

+ required: _context.Tree

+  def macro foo = 2

+                  ^

+one error found

diff --git a/test/files/neg/macro-nontree.flags b/test/files/neg/macro-nontree.flags
new file mode 100644
index 0000000000..7fea2ff901
--- /dev/null
+++ b/test/files/neg/macro-nontree.flags
@@ -0,0 +1 @@
+-Xmacros
\ No newline at end of file
diff --git a/test/files/neg/macro-nontree/Macros_1.scala b/test/files/neg/macro-nontree/Macros_1.scala
new file mode 100644
index 0000000000..2433974a85
--- /dev/null
+++ b/test/files/neg/macro-nontree/Macros_1.scala
@@ -0,0 +1,3 @@
+object Macros {
+  def macro foo = 2
+}
\ No newline at end of file
diff --git a/test/files/run/macro-basic.check b/test/files/run/macro-basic.check
new file mode 100644
index 0000000000..d434014897
--- /dev/null
+++ b/test/files/run/macro-basic.check
@@ -0,0 +1 @@
+10

diff --git a/test/files/run/macro-basic.flags b/test/files/run/macro-basic.flags
new file mode 100644
index 0000000000..06a7b31f11
--- /dev/null
+++ b/test/files/run/macro-basic.flags
@@ -0,0 +1 @@
+-Xmacros
diff --git a/test/files/run/macro-basic/Macros_1.scala b/test/files/run/macro-basic/Macros_1.scala
new file mode 100644
index 0000000000..c2ea183abe
--- /dev/null
+++ b/test/files/run/macro-basic/Macros_1.scala
@@ -0,0 +1,10 @@
+object Macros {
+  object Shmacros {
+    def macro foo(x: Int): Int = x
+  }
+  def macro bar(x: Int): Int = x
+}
+
+class Macros {
+  def macro quux(x: Int): Int = x
+}
\ No newline at end of file
diff --git a/test/files/run/macro-basic/Test_2.scala b/test/files/run/macro-basic/Test_2.scala
new file mode 100644
index 0000000000..e9a10e20c9
--- /dev/null
+++ b/test/files/run/macro-basic/Test_2.scala
@@ -0,0 +1,4 @@
+object Test extends App {
+  import Macros.Shmacros._
+  println(foo(2) + Macros.bar(2) * new Macros().quux(4))
+}
\ No newline at end of file
diff --git a/test/files/run/macro-repl-basic.check b/test/files/run/macro-repl-basic.check
new file mode 100644
index 0000000000..f8f0d3ad29
--- /dev/null
+++ b/test/files/run/macro-repl-basic.check
@@ -0,0 +1,25 @@
+Type in expressions to have them evaluated.

+Type :help for more information.

+

+scala> 

+

+scala> object Macros {

+  object Shmacros {

+    def macro foo(x: Int): Int = x

+  }

+  def macro bar(x: Int): Int = x

+}; class Macros {

+  def macro quux(x: Int): Int = x

+}

+defined module Macros

+defined class Macros

+

+scala> 

+

+scala> import Macros.Shmacros._

+import Macros.Shmacros._

+

+scala> println(foo(2) + Macros.bar(2) * new Macros().quux(4))

+10

+

+scala> 

diff --git a/test/files/run/macro-repl-basic.scala b/test/files/run/macro-repl-basic.scala
new file mode 100644
index 0000000000..9b1a53343b
--- /dev/null
+++ b/test/files/run/macro-repl-basic.scala
@@ -0,0 +1,18 @@
+import scala.tools.partest.ReplTest
+
+object Test extends ReplTest {
+  override def extraSettings = "-Xmacros"
+  def code = """
+    |object Macros {
+    |  object Shmacros {
+    |    def macro foo(x: Int): Int = x
+    |  }
+    |  def macro bar(x: Int): Int = x
+    |}; class Macros {
+    |  def macro quux(x: Int): Int = x
+    |}
+    |
+    |import Macros.Shmacros._
+    |println(foo(2) + Macros.bar(2) * new Macros().quux(4))
+    |""".stripMargin
+}
\ No newline at end of file
diff --git a/test/files/run/macro-repl-dontexpand.check b/test/files/run/macro-repl-dontexpand.check
new file mode 100644
index 0000000000..d2bb89b6f7
--- /dev/null
+++ b/test/files/run/macro-repl-dontexpand.check
@@ -0,0 +1,9 @@
+Type in expressions to have them evaluated.

+Type :help for more information.

+

+scala> 

+

+scala> def macro foo = ???

+foo: Any

+

+scala> 

diff --git a/test/files/run/macro-repl-dontexpand.scala b/test/files/run/macro-repl-dontexpand.scala
new file mode 100644
index 0000000000..254bce894c
--- /dev/null
+++ b/test/files/run/macro-repl-dontexpand.scala
@@ -0,0 +1,8 @@
+import scala.tools.partest.ReplTest
+
+object Test extends ReplTest {
+  override def extraSettings = "-Xmacros"
+  def code = """
+    |def macro foo = ???
+    |""".stripMargin
+}
\ No newline at end of file
diff --git a/test/files/run/macro-rettype-mismatch.check b/test/files/run/macro-rettype-mismatch.check
new file mode 100644
index 0000000000..f6e4bc09fd
--- /dev/null
+++ b/test/files/run/macro-rettype-mismatch.check
@@ -0,0 +1,5 @@
+error: type mismatch;
+ found   : Int(2)
+ required: String
+

+java.lang.Error: reflective compilation has failed

diff --git a/test/files/run/macro-rettype-mismatch.flags b/test/files/run/macro-rettype-mismatch.flags
new file mode 100644
index 0000000000..7fea2ff901
--- /dev/null
+++ b/test/files/run/macro-rettype-mismatch.flags
@@ -0,0 +1 @@
+-Xmacros
\ No newline at end of file
diff --git a/test/files/run/macro-rettype-mismatch/Macros_1.scala b/test/files/run/macro-rettype-mismatch/Macros_1.scala
new file mode 100644
index 0000000000..64e5b93468
--- /dev/null
+++ b/test/files/run/macro-rettype-mismatch/Macros_1.scala
@@ -0,0 +1,3 @@
+object Macros {
+  def macro foo(x: Int): String = x
+}
\ No newline at end of file
diff --git a/test/files/run/macro-rettype-mismatch/Test_2.scala b/test/files/run/macro-rettype-mismatch/Test_2.scala
new file mode 100644
index 0000000000..39a7c7ad1a
--- /dev/null
+++ b/test/files/run/macro-rettype-mismatch/Test_2.scala
@@ -0,0 +1,16 @@
+import scala.tools.nsc.reporters._
+import scala.tools.nsc.Settings
+import reflect.runtime.Mirror.ToolBox
+
+object Test extends App {
+  import scala.reflect.mirror._
+  val tree = Apply(Select(Ident("Macros"), newTermName("foo")), List(Literal(Constant(2))))
+
+  val stderr = new java.io.ByteArrayOutputStream()
+  Console.setErr(new java.io.PrintStream(stderr))
+
+  val reporter = new ConsoleReporter(new Settings)
+  val toolbox = new ToolBox(reporter)
+  try { toolbox.runExpr(tree) }
+  catch { case ex: Throwable => println(stderr); println(ex) }
+}
diff --git a/test/pending/run/macro-overload.check b/test/pending/run/macro-overload.check
new file mode 100644
index 0000000000..764f914e48
--- /dev/null
+++ b/test/pending/run/macro-overload.check
@@ -0,0 +1,4 @@
+object-Int
+object-String
+class-Int
+class-String
\ No newline at end of file
diff --git a/test/pending/run/macro-overload.flags b/test/pending/run/macro-overload.flags
new file mode 100644
index 0000000000..7fea2ff901
--- /dev/null
+++ b/test/pending/run/macro-overload.flags
@@ -0,0 +1 @@
+-Xmacros
\ No newline at end of file
diff --git a/test/pending/run/macro-overload/Macros_1.scala b/test/pending/run/macro-overload/Macros_1.scala
new file mode 100644
index 0000000000..f24c69ea7b
--- /dev/null
+++ b/test/pending/run/macro-overload/Macros_1.scala
@@ -0,0 +1,9 @@
+object Macros {
+  def macro bar(x: Int): Int = Apply(Select(Select(Ident("scala"), newTermName("Predef")), newTermName("println")), List(Literal(Constant("object-Int"))))
+  def macro bar(x: String): String = Apply(Select(Select(Ident("scala"), newTermName("Predef")), newTermName("println")), List(Literal(Constant("object-String"))))
+}
+
+class Macros {
+  def macro bar(x: Int): Int = Apply(Select(Select(Ident("scala"), newTermName("Predef")), newTermName("println")), List(Literal(Constant("class-Int"))))
+  def macro bar(x: String): String = Apply(Select(Select(Ident("scala"), newTermName("Predef")), newTermName("println")), List(Literal(Constant("class-String"))))
+}
\ No newline at end of file
diff --git a/test/pending/run/macro-overload/Test_2.scala b/test/pending/run/macro-overload/Test_2.scala
new file mode 100644
index 0000000000..75f6572e03
--- /dev/null
+++ b/test/pending/run/macro-overload/Test_2.scala
@@ -0,0 +1,6 @@
+object Test extends App {
+  Macros.bar(2)
+  Macros.bar("2")
+  new Macros.bar(2)
+  new Macros.bar("2")
+}
\ No newline at end of file