Merge branch 'develop'

Author: paulp

src/compiler/scala/reflect/internal/TreePrinters.scala

@@ -103,6 +103,16 @@ trait TreePrinters extends api.TreePrinters { self: SymbolTable =>
       }
     }
 
+    def printLabelParams(ps: List[Ident]) {
+      print("(")
+      printSeq(ps){printLabelParam}{print(", ")}
+      print(")")
+    }
+
+    def printLabelParam(p: Ident) {
+      print(symName(p, p.name)); printOpt(": ", TypeTree() setType p.tpe)
+    }
+
     def printValueParams(ts: List[ValDef]) {
       print("(")
       if (!ts.isEmpty) printFlags(ts.head.mods.flags & IMPLICIT, "")
@@ -219,7 +229,7 @@ trait TreePrinters extends api.TreePrinters { self: SymbolTable =>
           }
 
         case LabelDef(name, params, rhs) =>
-          print(symName(tree, name)); printRow(params, "(", ",", ")"); printBlock(rhs)
+          print(symName(tree, name)); printLabelParams(params); printBlock(rhs)
 
         case Import(expr, selectors) =>
           // Is this selector remapping a name (i.e, {name1 => name2})

src/compiler/scala/reflect/internal/Trees.scala

@@ -144,11 +144,9 @@ trait Trees extends api.Trees { self: SymbolTable =>
      *  less than the whole tree.
      */
     def summaryString: String = tree match {
-      case Select(qual, name) => qual.summaryString + "." + name.decode
-      case Ident(name)        => name.longString
       case Literal(const)     => "Literal(" + const + ")"
-      case t: DefTree         => t.shortClass + " `" + t.name.decode + "`"
-      case t: RefTree         => t.shortClass + " `" + t.name.longString + "`"
+      case Select(qual, name) => qual.summaryString + "." + name.decode
+      case t: NameTree        => t.name.longString
       case t                  =>
         t.shortClass + (
           if (t.symbol != null && t.symbol != NoSymbol) " " + t.symbol

src/compiler/scala/reflect/internal/Types.scala

@@ -97,7 +97,7 @@ trait Types extends api.Types { self: SymbolTable =>
    */
   private final val propagateParameterBoundsToTypeVars = sys.props contains "scalac.debug.prop-constraints"
 
-  protected val enableTypeVarExperimentals = settings.Xexperimental.value || settings.YvirtPatmat.value
+  protected val enableTypeVarExperimentals = settings.Xexperimental.value || !settings.XoldPatmat.value
 
   /** Empty immutable maps to avoid allocations. */
   private val emptySymMap   = immutable.Map[Symbol, Symbol]()

src/compiler/scala/reflect/internal/settings/MutableSettings.scala

@@ -43,5 +43,5 @@ abstract class MutableSettings extends AbsSettings {
   def Yrecursion: IntSetting
   def maxClassfileName: IntSetting
   def Xexperimental: BooleanSetting
-  def YvirtPatmat: BooleanSetting
+  def XoldPatmat: BooleanSetting
 }

src/compiler/scala/reflect/runtime/Settings.scala

@@ -34,5 +34,5 @@ class Settings extends internal.settings.MutableSettings {
   val maxClassfileName = new IntSetting(255)
   val Xexperimental = new BooleanSetting(false)
   val deepCloning = new BooleanSetting (false)
-  val YvirtPatmat = new BooleanSetting(false)
+  val XoldPatmat = new BooleanSetting(false)
 }

src/compiler/scala/tools/nsc/Global.scala

@@ -347,7 +347,7 @@ class Global(var currentSettings: Settings, var reporter: NscReporter) extends S
   override protected val etaExpandKeepsStar = settings.etaExpandKeepsStar.value
   // Here comes another one...
   override protected val enableTypeVarExperimentals = (
-    settings.Xexperimental.value || settings.YvirtPatmat.value
+    settings.Xexperimental.value || !settings.XoldPatmat.value
   )
 
   // True if -Xscript has been set, indicating a script run.

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

@@ -72,24 +72,18 @@ abstract class TreeGen extends reflect.internal.TreeGen with TreeDSL {
     Annotated(Ident(nme.synthSwitch), expr)
   }
 
-  // must be kept in synch with the codegen in PatMatVirtualiser
-  object VirtualCaseDef {
-    def unapply(b: Block): Option[(Assign, Tree, Tree)] = b match {
-      case Block(List(assign@Assign(keepGoingLhs, falseLit), matchRes), zero) => Some((assign, matchRes, zero)) // TODO: check tree annotation
-      case _ => None
-    }
-  }
-
   def hasSynthCaseSymbol(t: Tree) = (t.symbol ne null) && (t.symbol hasFlag (CASE | SYNTHETIC))
 
   // TODO: would be so much nicer if we would know during match-translation (i.e., type checking)
   // whether we should emit missingCase-style apply (and isDefinedAt), instead of transforming trees post-factum
   class MatchMatcher {
     def caseMatch(orig: Tree, selector: Tree, cases: List[CaseDef], wrap: Tree => Tree): Tree = unknownTree(orig)
     def caseVirtualizedMatch(orig: Tree, _match: Tree, targs: List[Tree], scrut: Tree, matcher: Tree): Tree = unknownTree(orig)
-    def caseVirtualizedMatchOpt(orig: Tree, zero: ValDef, x: ValDef, matchRes: ValDef, keepGoing: ValDef, stats: List[Tree], epilogue: Tree, wrap: Tree => Tree): Tree = unknownTree(orig)
+    def caseVirtualizedMatchOpt(orig: Tree, prologue: List[Tree], cases: List[Tree], matchEndDef: Tree, wrap: Tree => Tree): Tree = unknownTree(orig)
 
-    def apply(matchExpr: Tree): Tree = (matchExpr: @unchecked) match {
+    def genVirtualizedMatch(prologue: List[Tree], cases: List[Tree], matchEndDef: Tree): Tree = Block(prologue ++ cases, matchEndDef)
+
+    def apply(matchExpr: Tree): Tree = matchExpr match {
       // old-style match or virtpatmat switch
       case Match(selector, cases) => // println("simple match: "+ (selector, cases) + "for:\n"+ matchExpr )
         caseMatch(matchExpr, selector, cases, identity)
@@ -100,11 +94,15 @@ abstract class TreeGen extends reflect.internal.TreeGen with TreeDSL {
       case Apply(Apply(TypeApply(Select(tgt, nme.runOrElse), targs), List(scrut)), List(matcher)) if opt.virtPatmat => // println("virt match: "+ (tgt, targs, scrut, matcher) + "for:\n"+ matchExpr )
         caseVirtualizedMatch(matchExpr, tgt, targs, scrut, matcher)
       // optimized version of virtpatmat
-      case Block((zero: ValDef) :: (x: ValDef) :: (matchRes: ValDef) :: (keepGoing: ValDef) :: stats, epilogue) if opt.virtPatmat => // TODO: check tree annotation // println("virtopt match: "+ (zero, x, matchRes, keepGoing, stats) + "for:\n"+ matchExpr )
-        caseVirtualizedMatchOpt(matchExpr, zero, x, matchRes, keepGoing, stats, epilogue, identity)
+      case Block(stats, matchEndDef) if opt.virtPatmat && (stats forall hasSynthCaseSymbol) =>
+        // the assumption is once we encounter a case, the remainder of the block will consist of cases
+        // the prologue may be empty, usually it is the valdef that stores the scrut
+        val (prologue, cases) = stats span (s => !s.isInstanceOf[LabelDef])
+        caseVirtualizedMatchOpt(matchExpr, prologue, cases, matchEndDef, identity)
       // optimized version of virtpatmat
-      case Block(outerStats, orig@Block((zero: ValDef) :: (x: ValDef) :: (matchRes: ValDef) :: (keepGoing: ValDef) :: stats, epilogue)) if opt.virtPatmat => // TODO: check tree annotation // println("virt opt block match: "+ (zero, x, matchRes, keepGoing, stats, outerStats) + "for:\n"+ matchExpr )
-        caseVirtualizedMatchOpt(matchExpr, zero, x, matchRes, keepGoing, stats, epilogue, m => copyBlock(matchExpr, outerStats, m))
+      case Block(outerStats, orig@Block(stats, matchEndDef)) if opt.virtPatmat && (stats forall hasSynthCaseSymbol) =>
+        val (prologue, cases) = stats span (s => !s.isInstanceOf[LabelDef])
+        caseVirtualizedMatchOpt(matchExpr, prologue, cases, matchEndDef, m => copyBlock(matchExpr, outerStats, m))
       case other =>
         unknownTree(other)
     }
@@ -120,35 +118,6 @@ abstract class TreeGen extends reflect.internal.TreeGen with TreeDSL {
            }
   }
 
-  def withDefaultCase(matchExpr: Tree, defaultAction: Tree/*scrutinee*/ => Tree): Tree = {
-    object withDefaultTransformer extends MatchMatcher {
-      override def caseMatch(orig: Tree, selector: Tree, cases: List[CaseDef], wrap: Tree => Tree): Tree = {
-        val casesNoSynthCatchAll = dropSyntheticCatchAll(cases)
-        if (casesNoSynthCatchAll exists treeInfo.isDefaultCase) orig
-        else {
-          val defaultCase = CaseDef(Ident(nme.WILDCARD), EmptyTree, defaultAction(selector.duplicate))
-          wrap(Match(selector, casesNoSynthCatchAll :+ defaultCase))
-        }
-      }
-      override def caseVirtualizedMatch(orig: Tree, _match: Tree, targs: List[Tree], scrut: Tree, matcher: Tree): Tree = { import CODE._
-        ((matcher APPLY (scrut)) DOT nme.getOrElse) APPLY (defaultAction(scrut.duplicate)) // TODO: pass targs
-      }
-      override def caseVirtualizedMatchOpt(orig: Tree, zero: ValDef, x: ValDef, matchRes: ValDef, keepGoing: ValDef, stats: List[Tree], epilogue: Tree, wrap: Tree => Tree): Tree = { import CODE._
-        wrap(Block(
-          zero ::
-          x ::
-          matchRes ::
-          keepGoing ::
-          stats,
-          // replace `if (keepGoing) throw new MatchError(...) else matchRes` by `if (keepGoing) ${defaultAction(`x`)} else matchRes`
-          (IF (REF(keepGoing.symbol)) THEN defaultAction(x.rhs.duplicate) ELSE REF(matchRes.symbol))
-        ))
-      }
-    }
-    withDefaultTransformer(matchExpr)
-  }
-
-
   def mkCached(cvar: Symbol, expr: Tree): Tree = {
     val cvarRef = mkUnattributedRef(cvar)
     Block(

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

@@ -255,6 +255,7 @@ trait Trees extends reflect.internal.Trees { self: Global =>
 
   def resetAllAttrs[A <: Tree](x: A, leaveAlone: Tree => Boolean = null): A = new ResetAttrs(false, leaveAlone).transform(x)
   def resetLocalAttrs[A <: Tree](x: A, leaveAlone: Tree => Boolean = null): A = new ResetAttrs(true, leaveAlone).transform(x)
+  def resetLocalAttrsKeepLabels[A<:Tree](x: A, leaveAlone: Tree => Boolean = null): A = new ResetAttrs(true, leaveAlone, true).transform(x)
 
   /** A transformer which resets symbol and tpe fields of all nodes in a given tree,
    *  with special treatment of:
@@ -265,7 +266,7 @@ trait Trees extends reflect.internal.Trees { self: Global =>
    *
    *  (bq:) This transformer has mutable state and should be discarded after use
    */
-  private class ResetAttrs(localOnly: Boolean, leaveAlone: Tree => Boolean = null) {
+  private class ResetAttrs(localOnly: Boolean, leaveAlone: Tree => Boolean = null, keepLabels: Boolean = false) {
     val debug = settings.debug.value
     val trace = scala.tools.nsc.util.trace when debug
 
@@ -328,18 +329,18 @@ trait Trees extends reflect.internal.Trees { self: Global =>
               case EmptyTree =>
                 tree
               case _ =>
-                if (tree.hasSymbol && (!localOnly || (locals contains tree.symbol)))
+                if (tree.hasSymbol && (!localOnly || (locals contains tree.symbol)) && !(keepLabels && tree.symbol.isLabel))
                   tree.symbol = NoSymbol
                 tree.tpe = null
                 tree
             }
           }
-        }
+      }
     }
 
     def transform[T <: Tree](x: T): T = {
       if (localOnly)
-        new MarkLocals().traverse(x)
+      new MarkLocals().traverse(x)
 
       if (localOnly && debug) {
         assert(locals.size == orderedLocals.size)

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

@@ -70,6 +70,9 @@ trait ParsersCommon extends ScannersCommon {
 
     @inline final def inBracesOrNil[T](body: => List[T]): List[T] = inBracesOrError(body, Nil)
     @inline final def inBracesOrUnit[T](body: => Tree): Tree = inBracesOrError(body, Literal(Constant()))
+    @inline final def dropAnyBraces[T](body: => T): T =
+      if (in.token == LBRACE) inBraces(body)
+      else body
 
     @inline final def inBrackets[T](body: => T): T = {
       accept(LBRACKET)
@@ -1106,7 +1109,7 @@ self =>
      *  }}}
      *  @note  The returned tree does not yet have a position
      */
-    def literal(isNegated: Boolean = false): Tree = {
+    def literal(isNegated: Boolean = false, inPattern: Boolean = false): Tree = {
       def finish(value: Any): Tree = {
         val t = Literal(Constant(value))
         in.nextToken()
@@ -1115,7 +1118,7 @@ self =>
       if (in.token == SYMBOLLIT)
         Apply(scalaDot(nme.Symbol), List(finish(in.strVal)))
       else if (in.token == INTERPOLATIONID)
-        interpolatedString()
+        interpolatedString(inPattern)
       else finish(in.token match {
         case CHARLIT   => in.charVal
         case INTLIT    => in.intVal(isNegated).toInt
@@ -1141,7 +1144,7 @@ self =>
       }
     }
 
-    private def interpolatedString(): Tree = atPos(in.offset) {
+    private def interpolatedString(inPattern: Boolean = false): Tree = atPos(in.offset) {
       val start = in.offset
       val interpolator = in.name
 
@@ -1151,8 +1154,11 @@ self =>
       while (in.token == STRINGPART) {
         partsBuf += literal()
         exprBuf += {
-          if (in.token == IDENTIFIER) atPos(in.offset)(Ident(ident()))
-          else expr()
+          if (inPattern) dropAnyBraces(pattern())
+          else {
+            if (in.token == IDENTIFIER) atPos(in.offset)(Ident(ident()))
+            else expr()
+          }
         }
       }
       if (in.token == STRINGLIT) partsBuf += literal()
@@ -1837,7 +1843,7 @@ self =>
               case INTLIT | LONGLIT | FLOATLIT | DOUBLELIT =>
                 t match {
                   case Ident(nme.MINUS) =>
-                    return atPos(start) { literal(isNegated = true) }
+                    return atPos(start) { literal(isNegated = true, inPattern = true) }
                   case _ =>
                 }
               case _ =>
@@ -1855,7 +1861,7 @@ self =>
             atPos(start, start) { Ident(nme.WILDCARD) }
           case CHARLIT | INTLIT | LONGLIT | FLOATLIT | DOUBLELIT |
                STRINGLIT | INTERPOLATIONID | SYMBOLLIT | TRUE | FALSE | NULL =>
-            atPos(start) { literal() }
+            atPos(start) { literal(inPattern = true) }
           case LPAREN =>
             atPos(start)(makeParens(noSeq.patterns()))
           case XMLSTART =>

src/compiler/scala/tools/nsc/interactive/tests/core/CoreTestDefs.scala

@@ -81,7 +81,7 @@ private[tests] trait CoreTestDefs
         else {
           reporter.println("\naskHyperlinkPos for `" + tree.symbol.name + "` at " + format(pos) + " " + pos.source.file.name)
           val r = new Response[Position]
-          // `tree.symbol.sourceFile` was discovered to be null when testing -Yvirtpatmat on the akka presentation test, where a position had shifted to point to `Int`
+          // `tree.symbol.sourceFile` was discovered to be null when testing using virtpatmat on the akka presentation test, where a position had shifted to point to `Int`
           // askHyperlinkPos for `Int` at (73,19) pi.scala --> class Int in package scala has null sourceFile!
           val treePath = if (tree.symbol.sourceFile ne null) tree.symbol.sourceFile.path else null
           val treeName = if (tree.symbol.sourceFile ne null) tree.symbol.sourceFile.name else null