Merge pull request scala#42 from densh/topic/quasiquotes

improved modifier, flags and symbols splicing

Author: xeno-by

lib/scala-compiler-src.jar.desired.sha1

@@ -1 +1 @@
-562f3bf598b4b9c2f3e5e564726558d80df3c3ac ?scala-compiler-src.jar
+277f9d9de24b124ae1c6efd827d6f21a460b0334 ?scala-compiler-src.jar

lib/scala-compiler.jar.desired.sha1

@@ -1 +1 @@
-c3ed1693dd3197d9cfee13392a8f907cc48970a6 ?scala-compiler.jar
+9fc8f840d713d9b9a9125dbbd64bf1b084fd7819 ?scala-compiler.jar

lib/scala-library-src.jar.desired.sha1

@@ -1 +1 @@
-376f6c5ee4e3b50909b8bed2ee32202f9ca49748 ?scala-library-src.jar
+c701bd150c36b1803941057fe82585d3677595cb ?scala-library-src.jar

lib/scala-library.jar.desired.sha1

@@ -1 +1 @@
-e6d9ec7f7e1c207b41163045479ce571f1cbd8bd ?scala-library.jar
+d7a42b3854500ac0588410c85d65a2e0eab0b62b ?scala-library.jar

lib/scala-reflect-src.jar.desired.sha1

@@ -1 +1 @@
-73d9ba61872e32fdcd8e40f8c47de28bb43139c0 ?scala-reflect-src.jar
+2233de6eb7f9838ef786e57735b0c37bbfd02501 ?scala-reflect-src.jar

lib/scala-reflect.jar.desired.sha1

@@ -1 +1 @@
-a2551a5bf730d808a98fb477fddd66ba9b72dc2e ?scala-reflect.jar
+c8a1731c3fcb24641e24991d3107363a796747c3 ?scala-reflect.jar

src/compiler/scala/tools/nsc/ast/TreeGen.scala

@@ -115,7 +115,6 @@ abstract class TreeGen extends scala.reflect.internal.TreeGen with TreeDSL {
       else AppliedTypeTree(Ident(clazz), targs map TypeTree)
     ))
   }
-  def mkSuperInitCall: Select = Select(Super(This(tpnme.EMPTY), tpnme.EMPTY), nme.CONSTRUCTOR)
 
   def wildcardStar(tree: Tree) =
     atPos(tree.pos) { Typed(tree, Ident(tpnme.WILDCARD_STAR)) }

src/compiler/scala/tools/nsc/ast/Trees.scala

@@ -77,78 +77,6 @@ trait Trees extends scala.reflect.internal.Trees { self: Global =>
     case xs :: rest => rest.foldLeft(Apply(gen.mkSuperInitCall, xs): Tree)(Apply.apply)
   }
 
-    /** Generates a template with constructor corresponding to
-   *
-   *  constrmods (vparams1_) ... (vparams_n) preSuper { presupers }
-   *  extends superclass(args_1) ... (args_n) with mixins { self => body }
-   *
-   *  This gets translated to
-   *
-   *  extends superclass with mixins { self =>
-   *    presupers' // presupers without rhs
-   *    vparamss   // abstract fields corresponding to value parameters
-   *    def <init>(vparamss) {
-   *      presupers
-   *      super.<init>(args)
-   *    }
-   *    body
-   *  }
-   */
-  def Template(parents: List[Tree], self: ValDef, constrMods: Modifiers, vparamss: List[List[ValDef]], body: List[Tree], superPos: Position): Template = {
-    /* Add constructor to template */
-
-    // create parameters for <init> as synthetic trees.
-    var vparamss1 = mmap(vparamss) { vd =>
-      atPos(vd.pos.focus) {
-        val mods = Modifiers(vd.mods.flags & (IMPLICIT | DEFAULTPARAM | BYNAMEPARAM) | PARAM | PARAMACCESSOR)
-        ValDef(mods withAnnotations vd.mods.annotations, vd.name, vd.tpt.duplicate, vd.rhs.duplicate)
-      }
-    }
-    val (edefs, rest) = body span treeInfo.isEarlyDef
-    val (evdefs, etdefs) = edefs partition treeInfo.isEarlyValDef
-    val gvdefs = evdefs map {
-      case vdef @ ValDef(_, _, tpt, _) =>
-        copyValDef(vdef)(
-        // atPos for the new tpt is necessary, since the original tpt might have no position
-        // (when missing type annotation for ValDef for example), so even though setOriginal modifies the
-        // position of TypeTree, it would still be NoPosition. That's what the author meant.
-        tpt = atPos(vdef.pos.focus)(TypeTree() setOriginal tpt setPos tpt.pos.focus),
-        rhs = EmptyTree
-      )
-    }
-    val lvdefs = evdefs collect { case vdef: ValDef => copyValDef(vdef)(mods = vdef.mods | PRESUPER) }
-
-    val constrs = {
-      if (constrMods hasFlag TRAIT) {
-        if (body forall treeInfo.isInterfaceMember) List()
-        else List(
-          atPos(wrappingPos(superPos, lvdefs)) (
-            DefDef(NoMods, nme.MIXIN_CONSTRUCTOR, List(), ListOfNil, TypeTree(), Block(lvdefs, Literal(Constant())))))
-      } else {
-        // convert (implicit ... ) to ()(implicit ... ) if its the only parameter section
-        if (vparamss1.isEmpty || !vparamss1.head.isEmpty && vparamss1.head.head.mods.isImplicit)
-          vparamss1 = List() :: vparamss1
-        val superRef: Tree = atPos(superPos)(gen.mkSuperInitCall)
-        val superCall = pendingSuperCall // we can't know in advance which of the parents will end up as a superclass
-                                         // this requires knowing which of the parents is a type macro and which is not
-                                         // and that's something that cannot be found out before typer
-                                         // (the type macros aren't in the trunk yet, but there is a plan for them to land there soon)
-                                         // this means that we don't know what will be the arguments of the super call
-                                         // therefore here we emit a dummy which gets populated when the template is named and typechecked
-        List(
-          // TODO: previously this was `wrappingPos(superPos, lvdefs ::: argss.flatten)`
-          // is it going to be a problem that we can no longer include the `argss`?
-          atPos(wrappingPos(superPos, lvdefs)) (
-            DefDef(constrMods, nme.CONSTRUCTOR, List(), vparamss1, TypeTree(), Block(lvdefs ::: List(superCall), Literal(Constant())))))
-      }
-    }
-    constrs foreach (ensureNonOverlapping(_, parents ::: gvdefs, focus=false))
-    // Field definitions for the class - remove defaults.
-    val fieldDefs = vparamss.flatten map (vd => copyValDef(vd)(mods = vd.mods &~ DEFAULTPARAM, rhs = EmptyTree))
-
-    Template(parents, self, gvdefs ::: fieldDefs ::: constrs ::: etdefs ::: rest)
-  }
-
   /** Construct class definition with given class symbol, value parameters,
    *  supercall arguments and template body.
    *
@@ -167,9 +95,9 @@ trait Trees extends scala.reflect.internal.Trees { self: Global =>
     )
 
     ClassDef(sym,
-      Template(sym.info.parents map TypeTree,
-               if (sym.thisSym == sym || phase.erasedTypes) emptyValDef else ValDef(sym.thisSym),
-               constrMods, vparamss, body, superPos))
+      gen.mkTemplate(sym.info.parents map TypeTree,
+                     if (sym.thisSym == sym || phase.erasedTypes) emptyValDef else ValDef(sym.thisSym),
+                     constrMods, vparamss, body, superPos))
   }
 
  // --- subcomponents --------------------------------------------------

src/compiler/scala/tools/nsc/ast/parser/Parsers.scala

@@ -608,6 +608,8 @@ self =>
       case _ => false
     }
 
+    def isAnnotation: Boolean = in.token == AT
+
     def isLocalModifier: Boolean = in.token match {
       case ABSTRACT | FINAL | SEALED | IMPLICIT | LAZY => true
       case _ => false
@@ -1410,7 +1412,7 @@ self =>
               } else {
                 syntaxErrorOrIncomplete("`*' expected", true)
               }
-            } else if (in.token == AT) {
+            } else if (isAnnotation) {
               t = (t /: annotations(skipNewLines = false))(makeAnnotated)
             } else {
               t = atPos(t.pos.startOrPoint, colonPos) {
@@ -2855,7 +2857,7 @@ self =>
         if (inScalaRootPackage && ScalaValueClassNames.contains(name))
           Template(parents0, self, anyvalConstructor :: body)
         else
-          Template(anyrefParents(), self, constrMods, vparamss, body, o2p(tstart))
+          gen.mkTemplate(anyrefParents(), self, constrMods, vparamss, body, o2p(tstart))
       }
     }
 
@@ -2956,7 +2958,7 @@ self =>
           case IMPORT =>
             in.flushDoc
             importClause()
-          case x if x == AT || isTemplateIntro || isModifier =>
+          case _ if isAnnotation || isTemplateIntro || isModifier =>
             joinComment(List(topLevelTmplDef))
           case _ =>
             if (!isStatSep)
@@ -3013,11 +3015,11 @@ self =>
         if (in.token == IMPORT) {
           in.flushDoc
           stats ++= importClause()
+        } else if (isDefIntro || isModifier || isAnnotation) {
+          stats ++= joinComment(nonLocalDefOrDcl)
         } else if (isExprIntro) {
           in.flushDoc
           stats += statement(InTemplate)
-        } else if (isDefIntro || isModifier || in.token == AT) {
-          stats ++= joinComment(nonLocalDefOrDcl)
         } else if (!isStatSep) {
           syntaxErrorOrIncomplete("illegal start of definition", true)
         }
@@ -3097,7 +3099,7 @@ self =>
           stats += statement(InBlock)
           if (in.token != RBRACE && in.token != CASE) acceptStatSep()
         }
-        else if (isDefIntro || isLocalModifier || in.token == AT) {
+        else if (isDefIntro || isLocalModifier || isAnnotation) {
           if (in.token == IMPLICIT) {
             val start = in.skipToken()
             if (isIdent) stats += implicitClosure(start, InBlock)

src/compiler/scala/tools/nsc/ast/parser/Scanners.scala

@@ -80,7 +80,21 @@ trait Scanners extends ScannersCommon {
     }
   }
 
-  abstract class Scanner extends CharArrayReader with TokenData with ScannerCommon {
+  trait ScannerData extends TokenData {
+    var ch: Char
+    var charOffset: Int
+    var lineStartOffset: Int
+    var lastLineStartOffset: Int
+    def copyFrom(sd: ScannerData) = {
+      this.ch = sd.ch
+      this.charOffset = sd.charOffset
+      this.lineStartOffset = sd.lineStartOffset
+      this.lastLineStartOffset = sd.lastLineStartOffset
+      super.copyFrom(sd)
+    }
+  }
+
+  abstract class Scanner extends CharArrayReader with TokenData with ScannerData with ScannerCommon {
     private def isDigit(c: Char) = java.lang.Character isDigit c
 
     def isAtEnd = charOffset >= buf.length

src/compiler/scala/tools/nsc/ast/parser/TreeBuilder.scala

@@ -225,7 +225,7 @@ abstract class TreeBuilder {
             atPos(cpos) {
               ClassDef(
                 Modifiers(FINAL), x, Nil,
-                Template(parents, self, NoMods, ListOfNil, stats, cpos.focus))
+                gen.mkTemplate(parents, self, NoMods, ListOfNil, stats, cpos.focus))
             }),
           atPos(npos) {
             New(

src/compiler/scala/tools/nsc/typechecker/Unapplies.scala

@@ -136,7 +136,7 @@ trait Unapplies extends ast.TreeDSL
     ModuleDef(
       Modifiers(cdef.mods.flags & AccessFlags | SYNTHETIC, cdef.mods.privateWithin),
       cdef.name.toTermName,
-      Template(parents, emptyValDef, NoMods, Nil, body, cdef.impl.pos.focus))
+      gen.mkTemplate(parents, emptyValDef, NoMods, Nil, body, cdef.impl.pos.focus))
   }
 
   private val caseMods = Modifiers(SYNTHETIC | CASE)

src/compiler/scala/tools/reflect/ToolBoxFactory.scala

@@ -225,7 +225,7 @@ abstract class ToolBoxFactory[U <: JavaUniverse](val u: U) { factorySelf =>
 
           val moduledef = ModuleDef(
               obj,
-              Template(
+              gen.mkTemplate(
                   List(TypeTree(ObjectClass.tpe)),
                   emptyValDef,
                   NoMods,

src/compiler/scala/tools/reflect/quasiquotes/Macros.scala

@@ -9,12 +9,6 @@ import scala.collection.immutable.ListMap
 trait Macros { self: Quasiquotes =>
   import c.universe._
 
-  /** This is a shorcut variable that links to "$u" universe variable name.
-   *  With the help of it it's possible to use $u inside of the quasiquote
-   *  and it will have the same meaning in expanded code.
-   */
-  val u = nme.UNIVERSE_SHORT
-
   /** This trait abstracts over all variations of quasiquotes
    *  and allows to share core logic. The main differences are
    *  in parser, reifier and wrapping behaviour.
@@ -26,9 +20,6 @@ trait Macros { self: Quasiquotes =>
     /** Reifier factory that abstracts over different reifiers need for apply and unapply macros. */
     def reifier(universe: Tree, placeholders: Placeholders): Reifier
 
-    /** Wraps reified tree into a final result of macro expansion. */
-    def wrap(universe: Tree, reified: Tree): Tree
-
     /** Extracts universe tree, args trees and params strings from macroApplication. */
     def extract = c.macroApplication match {
       case q"$universe.Quasiquote($stringContext.apply(..$parts0)).${_}.${_}(..$args)" =>
@@ -46,7 +37,7 @@ trait Macros { self: Quasiquotes =>
     /** Generates scala code to be parsed by parser and placeholders map from incoming args and parts. */
     def generate(args: List[Tree], parts: List[String]): (String, Placeholders) = {
       val sb = new StringBuilder()
-      var placeholders = ListMap[String, (Tree, Int)]()
+      var pmap = ListMap[String, (Tree, Int)]()
 
       foreach2(args, parts.init) { (tree, p) =>
         val (part, cardinality) =
@@ -59,52 +50,41 @@ trait Macros { self: Quasiquotes =>
         val freshname = c.fresh(nme.QUASIQUOTE_PREFIX)
         sb.append(part)
         sb.append(freshname)
-        placeholders += freshname -> (tree, cardinality)
+        pmap += freshname -> (tree, cardinality)
       }
       sb.append(parts.last)
 
-      (sb.toString, placeholders)
+      (sb.toString, Placeholders(pmap))
     }
 
-    def debug(msg: String) =
-      if (settings.Yquasiquotedebug.value) println(msg)
-
     /** Quasiquote macro expansion core logic. */
     def apply() = {
       val (universe, args, parts) = extract
       val (code, placeholders) = generate(args, parts)
       debug(s"\ncode to parse=\n$code\n")
       val tree = parser.parse(code, placeholders.keys.toSet)
       debug(s"parsed tree\n=${tree}\n=${showRaw(tree)}\n")
-      val reified = reifier(universe, placeholders).reify(tree)
+      val reified = reifier(universe, placeholders).quasiquoteReify(tree)
       debug(s"reified tree\n=${reified}\n=${showRaw(reified)}\n")
-      val result = wrap(universe, reified)
-      debug(s"result tree\n=${result}\n=${showRaw(result)}\n")
-      result
+      reified
     }
   }
 
-  trait ApplyMacro extends AbstractMacro {
+  trait ApplyReification {
     def reifier(universe: Tree, placeholders: Placeholders): Reifier =
-      new ApplyReifier(universe, placeholders)
-    def wrap(universe: Tree, reified: Tree): Tree =
-      q"""{
-        val $u: $universe.type = $universe
-        $reified
-      }"""
+      new ApplyReifierWithSymbolSplicing(universe, placeholders)
   }
 
-  trait UnapplyMacro extends AbstractMacro {
+  trait UnapplyReification {
     def reifier(universe: Tree, placeholders: Placeholders): Reifier =
       new UnapplyReifier(universe, placeholders)
-    def wrap(universe: Tree, reified: Tree) = reified
   }
 
   trait TermParsing { val parser = TermParser }
   trait TypeParsing { val parser = TypeParser }
 
-  def applyQ = (new ApplyMacro with TermParsing).apply()
-  def applyTq = (new ApplyMacro with TypeParsing).apply()
-  def unapplyQ = (new UnapplyMacro with TermParsing).apply()
-  def unapplyTq = (new UnapplyMacro with TypeParsing).apply()
+  def applyQ = (new AbstractMacro with ApplyReification with TermParsing).apply()
+  def applyTq = (new AbstractMacro with ApplyReification with TypeParsing).apply()
+  def unapplyQ = (new AbstractMacro with UnapplyReification with TermParsing).apply()
+  def unapplyTq = (new AbstractMacro with UnapplyReification with TypeParsing).apply()
 }