fixed bugs 1143, 1136, 1102

13 files changed, 138 insertions, 50 deletions

diff --git a/src/compiler/scala/tools/nsc/CompilerCommand.scala b/src/compiler/scala/tools/nsc/CompilerCommand.scala
index 89302b0749..d246e05959 100644
--- a/src/compiler/scala/tools/nsc/CompilerCommand.scala
+++ b/src/compiler/scala/tools/nsc/CompilerCommand.scala
@@ -24,6 +24,7 @@ class CompilerCommand(arguments: List[String], val settings: Settings,
 
   /** A message explaining usage and options */
   def usageMsg: String = {
+    // todo: print -X and -javadoc options only on demand
     val helpSyntaxColumnWidth: int =
       Iterable.max(settings.allSettings map (. helpSyntax.length()))
     def format(s: String): String = {
diff --git a/src/compiler/scala/tools/nsc/Global.scala b/src/compiler/scala/tools/nsc/Global.scala
index 31e4f162a3..9d76ab531c 100644
--- a/src/compiler/scala/tools/nsc/Global.scala
+++ b/src/compiler/scala/tools/nsc/Global.scala
@@ -497,8 +497,10 @@ class Global(var settings: Settings, var reporter: Reporter) extends SymbolTable
         phase = globalPhase
         globalPhase.run
         if (settings.print contains globalPhase.name)
-          if (globalPhase.id >=  icodePhase.id) writeICode()
+          if (globalPhase.id >= icodePhase.id) writeICode()
+          else if (settings.Xshowtrees.value) nodePrinters.printAll()
           else treePrinter.printAll()
+
         if (settings.browse contains globalPhase.name) treeBrowser.browse(units)
         informTime(globalPhase.description, startTime)
         globalPhase = globalPhase.next
diff --git a/src/compiler/scala/tools/nsc/Settings.scala b/src/compiler/scala/tools/nsc/Settings.scala
index 848fc8a8f1..626c41cfd9 100644
--- a/src/compiler/scala/tools/nsc/Settings.scala
+++ b/src/compiler/scala/tools/nsc/Settings.scala
@@ -125,6 +125,7 @@ class Settings(error: String => unit) {
   val Xdetach       = BooleanSetting("-Xdetach", "Perform detaching of remote closures")
   val Xshowcls      = StringSetting ("-Xshowcls", "class", "Show class info", "")
   val Xshowobj      = StringSetting ("-Xshowobj", "object", "Show object info", "")
+  val Xshowtrees    = BooleanSetting ("-Xshowtrees", "Show detailed trees when used in connection with -print:phase")
   val Xlinearizer   = ChoiceSetting ("-Xlinearizer", "Linearizer to use", List("normal", "dfs", "rpo", "dump"), "rpo")
   val Xgenerics     = BooleanSetting("-Xgenerics", "Use generic Java types")
   val Xprintpos     = BooleanSetting("-Xprintpos", "Print tree positions (as offsets)")
diff --git a/src/compiler/scala/tools/nsc/ast/NodePrinters.scala b/src/compiler/scala/tools/nsc/ast/NodePrinters.scala
index 31cc368ec8..24fd0971cd 100644
--- a/src/compiler/scala/tools/nsc/ast/NodePrinters.scala
+++ b/src/compiler/scala/tools/nsc/ast/NodePrinters.scala
@@ -232,8 +232,34 @@ abstract class NodePrinters {
             traverse(tpt, level + 1, true)
             traverse(rhs, level + 1, false)
             printcln(")")
+          case PackageDef(name, stats) =>
+            println("PackageDef("+name+", ")
+            for (stat <- stats)
+              traverse(stat, level + 1, false)
+            printcln(")")
           case _ =>
-            printcln("***" + tree.getClass)
+            tree match {
+              case p: Product =>
+                if (p.productArity != 0) {
+                  println(p.productPrefix+"(")
+                  for (elem <- (0 until p.productArity) map p.productElement) {
+                    def printElem(elem: Any, level: int): unit = elem match {
+                      case t: Tree =>
+                        traverse(t, level, false)
+                      case xs: List[_] =>
+                        print("List(")
+                        for (x <- xs) printElem(x, level+1)
+                        printcln(")")
+                      case _ =>
+                        println(elem.toString)
+                    }
+                    printElem(elem, level+1)
+                  }
+                  printcln(")")
+                } else printcln(p.productPrefix)
+              case _ =>
+                printcln("***" + tree.getClass)
+            }
         }
       }
       buf setLength 0
@@ -241,4 +267,17 @@ abstract class NodePrinters {
       buf.toString
     }
   }
+  def printUnit(unit: CompilationUnit) {
+    print("// Scala source: " + unit.source + "\n")
+    if (unit.body ne null) {
+      print(nodeToString(unit.body)); println()
+    } else {
+      print("<null>")
+    }
+    println()
+  }
+  def printAll() {
+    print("[[syntax trees at end of " + phase + "]]")
+    for (unit <- global.currentRun.units) printUnit(unit)
+  }
 }
diff --git a/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala b/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala
index c938abb4bf..66168724b0 100644
--- a/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala
+++ b/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala
@@ -2239,6 +2239,8 @@ trait Parsers {
      *                     |
      */
     def templateStatSeq() = {
+      val savedImplicitParams = implicitParams
+      implicitParams = List()
       var self: ValDef = emptyValDef
       val stats = new ListBuffer[Tree]
       if (isExprIntro) {
@@ -2266,6 +2268,7 @@ trait Parsers {
         if (inToken != RBRACE && inToken != EOF) acceptStatSep()
       }
       checkNoImplicitParams()
+      implicitParams = savedImplicitParams
       (self, stats.toList)
     }
 
@@ -2305,6 +2308,8 @@ trait Parsers {
         if (inToken == RBRACE || inToken == CASE)
           stats += Literal(()).setPos(inCurrentPos)
       }
+      val savedImplicitParams = implicitParams
+      implicitParams = List()
       var last = false
       while ((inToken != RBRACE) && (inToken != EOF) && (inToken != CASE) && !last) {
         if (inToken == IMPORT) {
@@ -2324,6 +2329,7 @@ trait Parsers {
         }
       }
       checkNoImplicitParams()
+      implicitParams = savedImplicitParams
       stats.toList
     }
 
diff --git a/src/compiler/scala/tools/nsc/symtab/AnnotationInfos.scala b/src/compiler/scala/tools/nsc/symtab/AnnotationInfos.scala
index 8b36ad819f..e1d72105ca 100644
--- a/src/compiler/scala/tools/nsc/symtab/AnnotationInfos.scala
+++ b/src/compiler/scala/tools/nsc/symtab/AnnotationInfos.scala
@@ -41,7 +41,7 @@ trait AnnotationInfos {
         None
     }
 
-  private object symbolReifier extends SymbolReifier {
+  private val symbolReifier = new SymbolReifier {
     val symbols: AnnotationInfos.this.type = AnnotationInfos.this
   }
 
diff --git a/src/compiler/scala/tools/nsc/symtab/Flags.scala b/src/compiler/scala/tools/nsc/symtab/Flags.scala
index 4c5f227a21..83b538ee9d 100644
--- a/src/compiler/scala/tools/nsc/symtab/Flags.scala
+++ b/src/compiler/scala/tools/nsc/symtab/Flags.scala
@@ -65,7 +65,7 @@ object Flags extends Enumeration {
   final val LIFTED        = 0x400000000L  // class has been lifted out to package level
                                           // local value has been lifted out to class level
                                           // todo: make LIFTED = latePRIVATE?
-  final val MIXEDIN       = 0x800000000L  // member has been mixed in
+  final val MIXEDIN       = 0x800000000L  // term member has been mixed in
 
   final val EXPANDEDNAME  = 0x1000000000L // name has been expanded with class suffix
   final val IMPLCLASS     = 0x2000000000L // symbol is an implementation class
diff --git a/src/compiler/scala/tools/nsc/symtab/StdNames.scala b/src/compiler/scala/tools/nsc/symtab/StdNames.scala
index fd1893054c..d6efdb32cb 100644
--- a/src/compiler/scala/tools/nsc/symtab/StdNames.scala
+++ b/src/compiler/scala/tools/nsc/symtab/StdNames.scala
@@ -302,6 +302,7 @@ trait StdNames {
     val receive = newTermName("receive")
     val report = newTermName("report")
     val runtime = newTermName("runtime")
+    val sameElements = newTermName("sameElements")
     val scala_ = newTermName("scala")
     val send = newTermName("send")
     val synchronized_ = newTermName("synchronized")
diff --git a/src/compiler/scala/tools/nsc/symtab/Symbols.scala b/src/compiler/scala/tools/nsc/symtab/Symbols.scala
index c1d2d222ea..81ba6b5b9e 100644
--- a/src/compiler/scala/tools/nsc/symtab/Symbols.scala
+++ b/src/compiler/scala/tools/nsc/symtab/Symbols.scala
@@ -677,7 +677,6 @@ trait Symbols {
     def thisType: Type = NoPrefix
 
     /** Return every accessor of a primary constructor parameter in this case class
-      * todo: limit to accessors for first constructor parameter section.
       */
     final def caseFieldAccessors: List[Symbol] =
       info.decls.toList filter (sym => !(sym hasFlag PRIVATE) && sym.hasFlag(CASEACCESSOR))
diff --git a/src/compiler/scala/tools/nsc/typechecker/Infer.scala b/src/compiler/scala/tools/nsc/typechecker/Infer.scala
index ac009e4c3e..80ba2c1df1 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Infer.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Infer.scala
@@ -630,18 +630,19 @@ trait Infer {
         false
     }
 
-    /** Is type `tpe1' a strictly better alternative than type `ftpe2'?
-     *
-     *  @param tpe1 ...
-     *  @param tpe2 ...
-     *  @return     ...
+    /** Is type `tpe1' a strictly better expression alternative than type `tpe2'?
      */
-    def isStrictlyBetter(tpe1: Type, tpe2: Type) = {
+    def isStrictlyBetterExpr(tpe1: Type, tpe2: Type) = {
       def isNullary(tpe: Type) = tpe.paramSectionCount == 0 || tpe.paramTypes.isEmpty
       isNullary(tpe1) && !isNullary(tpe2) ||
-      specializes(tpe1, tpe2) && !specializes(tpe2, tpe1)
+      isStrictlyBetter(tpe1, tpe2)
     }
 
+    /** Is type `tpe1' a strictly better alternative than type `tpe2'?
+     */
+    def isStrictlyBetter(tpe1: Type, tpe2: Type) =
+      specializes(tpe1, tpe2) && !specializes(tpe2, tpe1)
+
     /** error if arguments not within bounds. */
     def checkBounds(pos: Position, pre: Type, owner: Symbol,
                     tparams: List[Symbol], targs: List[Type], prefix: String) = {
@@ -1132,7 +1133,7 @@ trait Infer {
             val tp2 = pre.memberType(sym2)
             (tp2 == ErrorType ||
              !global.typer.infer.isCompatible(tp2, pt) && global.typer.infer.isCompatible(tp1, pt) ||
-             isStrictlyBetter(tp1, tp2)) }
+             isStrictlyBetterExpr(tp1, tp2)) }
         val best = ((NoSymbol: Symbol) /: alts1) ((best, alt) =>
           if (improves(alt, best)) alt else best)
         val competing = alts1 dropWhile (alt => best == alt || improves(best, alt))
@@ -1176,10 +1177,9 @@ trait Infer {
         tryTwice {
           if (settings.debug.value) log("infer method alt " + tree.symbol + " with alternatives " + (alts map pre.memberType) + ", argtpes = " + argtpes + ", pt = " + pt)
           val applicable = alts filter (alt => isApplicable(undetparams, pre.memberType(alt), argtpes, pt))
-          def improves(sym1: Symbol, sym2: Symbol) = (
+          def improves(sym1: Symbol, sym2: Symbol) =
             sym2 == NoSymbol || sym2.isError ||
-            specializes(pre.memberType(sym1), pre.memberType(sym2))
-          )
+            isStrictlyBetter(pre.memberType(sym1), pre.memberType(sym2))
           val best = ((NoSymbol: Symbol) /: applicable) ((best, alt) =>
             if (improves(alt, best)) alt else best)
           val competing = applicable dropWhile (alt => best == alt || improves(best, alt))
diff --git a/src/compiler/scala/tools/nsc/typechecker/SyntheticMethods.scala b/src/compiler/scala/tools/nsc/typechecker/SyntheticMethods.scala
index 1872642459..d91426867d 100644
--- a/src/compiler/scala/tools/nsc/typechecker/SyntheticMethods.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/SyntheticMethods.scala
@@ -37,7 +37,9 @@ trait SyntheticMethods requires Analyzer {
    *  @param unit  ...
    *  @return      ...
    */
-  def addSyntheticMethods(templ: Template, clazz: Symbol, unit: CompilationUnit): Template = {
+  def addSyntheticMethods(templ: Template, clazz: Symbol, context: Context): Template = {
+
+    val localTyper = newTyper(context)
 
     def hasImplementation(name: Name): boolean = {
       val sym = clazz.info.nonPrivateMember(name)
@@ -111,32 +113,66 @@ trait SyntheticMethods requires Analyzer {
         Apply(gen.mkAttributedRef(target), This(clazz) :: (vparamss.head map Ident))))
     }
 
+    /** The equality method for case classes and modules:
+     *   def equals(that: Any) =
+     *     (this eq that) ||
+     *     (that match {
+     *       case this.C(this.arg_1, ..., this.arg_n) => true
+     *       case _ => false
+     *     })
+     */
     def equalsMethod: Tree = {
-      val constrParamTypes = clazz.primaryConstructor.tpe.paramTypes
-      val hasVarArgs = !constrParamTypes.isEmpty && constrParamTypes.last.symbol == RepeatedParamClass
-      val target = getMember(ScalaRunTimeModule, if (hasVarArgs) nme._equalsWithVarArgs else nme._equals)
-      val paramtypes =
-        if (target.tpe.paramTypes.isEmpty) List()
-        else target.tpe.paramTypes.tail
       val method = syntheticMethod(
-       nme.equals_, 0, MethodType(paramtypes, target.tpe.resultType))
-      typed(DefDef(method, vparamss =>
-        Apply(
-          Select(
-            Apply(
-              Select(Ident(vparamss.head.head), Object_eq),
-              List(This(clazz))),
-            Boolean_or),
-          List(
-            Apply(
-              Select(
-                TypeApply(
-                  Select(Ident(vparamss.head.head), Any_isInstanceOf),
-                  List(TypeTree(clazz.tpe))),
-                Boolean_and),
-              List(
-                Apply(gen.mkAttributedRef(target),
-                      This(clazz) :: (vparamss.head map Ident))))))));
+        nme.equals_, 0, MethodType(List(AnyClass.tpe), BooleanClass.tpe))
+      localTyper.typed {
+        DefDef(
+          method,
+          { vparamss =>
+            val that = Ident(vparamss.head.head)
+            val constrParamTypes = clazz.primaryConstructor.tpe.paramTypes
+            val hasVarArgs = !constrParamTypes.isEmpty && constrParamTypes.last.symbol == RepeatedParamClass
+            if (clazz.isStatic) {
+              val target = getMember(ScalaRunTimeModule, if (hasVarArgs) nme._equalsWithVarArgs else nme._equals)
+              Apply(
+                Select(
+                  TypeApply(
+                    Select(that, Any_isInstanceOf),
+                    List(TypeTree(clazz.tpe))),
+                  Boolean_and),
+                List(
+                  Apply(gen.mkAttributedRef(target),
+                        This(clazz) :: (vparamss.head map Ident))))
+            } else {
+              val (pat, guard) = {
+                val guards = new ListBuffer[Tree]
+                val params = for ((acc, cpt) <- clazz.caseFieldAccessors zip constrParamTypes) yield {
+                  val name = context.unit.fresh.newName(acc.name+"$")
+                  val isVarArg = cpt.symbol == RepeatedParamClass
+                  guards += Apply(
+                    Select(
+                      Ident(name),
+                      if (isVarArg) nme.sameElements else nme.equals_),
+                    List(Ident(acc)))
+                  Bind(name,
+                       if (isVarArg) Star(Ident(nme.WILDCARD))
+                       else Ident(nme.WILDCARD))
+                }
+                ( Apply(Ident(clazz.name.toTermName), params),
+                  if (guards.isEmpty) EmptyTree
+                  else guards reduceLeft { (g1: Tree, g2: Tree) =>
+                    Apply(Select(g1, nme.AMPAMP), List(g2))
+                  }
+                )
+              }
+              Match(
+                that,
+                List(
+                  CaseDef(pat, guard, Literal(Constant(true))),
+                  CaseDef(Ident(nme.WILDCARD), EmptyTree, Literal(Constant(false)))))
+            }
+          }
+        )
+      }
     }
 
     def isSerializable(clazz: Symbol): Boolean =
@@ -153,8 +189,8 @@ trait SyntheticMethods requires Analyzer {
     def newAccessorMethod(tree: Tree): Tree = tree match {
       case DefDef(_, _, _, _, _, rhs) =>
         val newAcc = tree.symbol.cloneSymbol
-        newAcc.name = unit.fresh.newName("" + tree.symbol.name + "$")
-        newAcc.setFlag(SYNTHETIC).resetFlag(ACCESSOR | PARAMACCESSOR)
+        newAcc.name = context.unit.fresh.newName(tree.symbol.name + "$")
+        newAcc.setFlag(SYNTHETIC).resetFlag(ACCESSOR | PARAMACCESSOR | PRIVATE)
         newAcc.owner.info.decls enter newAcc
         val result = typed(DefDef(newAcc, vparamss => rhs.duplicate))
         log("new accessor method " + result)
@@ -163,7 +199,7 @@ trait SyntheticMethods requires Analyzer {
 
     def beanSetterOrGetter(sym: Symbol): Symbol =
       if (!sym.name(0).isLetter) {
-        unit.error(sym.pos, "attribute `BeanProperty' can be applied only to fields that start with a letter")
+        context.unit.error(sym.pos, "attribute `BeanProperty' can be applied only to fields that start with a letter")
         NoSymbol
       } else {
         var name0 = sym.name
@@ -174,7 +210,7 @@ trait SyntheticMethods requires Analyzer {
         val name1 = prefix + name0(0).toUpperCase + name0.subName(1, name0.length)
         val sym1 = clazz.info.decl(name1)
         if (sym1 != NoSymbol && sym1.tpe.paramTypes.length == arity) {
-          unit.error(sym.pos, "a definition of `"+name1+"' already exists in " + clazz)
+          context.unit.error(sym.pos, "a definition of `"+name1+"' already exists in " + clazz)
           NoSymbol
         } else {
           clazz.newMethod(sym.pos, name1)
@@ -251,7 +287,7 @@ trait SyntheticMethods requires Analyzer {
             else if (sym.isSetter)
               addBeanSetterMethod(sym)
             else if (sym.isMethod || sym.isType)
-              unit.error(sym.pos, "attribute `BeanProperty' is not applicable to " + sym)
+              context.unit.error(sym.pos, "attribute `BeanProperty' is not applicable to " + sym)
     }
     val synthetics = ts.toList
     copy.Template(
diff --git a/src/compiler/scala/tools/nsc/typechecker/Typers.scala b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
index 30f693155d..7b6d84acb8 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Typers.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
@@ -939,7 +939,7 @@ trait Typers requires Analyzer {
       val tparams1 = List.mapConserve(cdef.tparams)(typedAbsTypeDef)
       val impl1 = newTyper(context.make(cdef.impl, clazz, newTemplateScope(cdef.impl, clazz)))
         .typedTemplate(cdef.impl, parentTypes(cdef.impl))
-      val impl2 = addSyntheticMethods(impl1, clazz, context.unit)
+      val impl2 = addSyntheticMethods(impl1, clazz, context)
       copy.ClassDef(cdef, cdef.mods, cdef.name, tparams1, impl2)
         .setType(NoType)
     }
@@ -954,7 +954,7 @@ trait Typers requires Analyzer {
       val clazz = mdef.symbol.moduleClass
       val impl1 = newTyper(context.make(mdef.impl, clazz, newTemplateScope(mdef.impl, clazz)))
         .typedTemplate(mdef.impl, parentTypes(mdef.impl))
-      val impl2 = addSyntheticMethods(impl1, clazz, context.unit)
+      val impl2 = addSyntheticMethods(impl1, clazz, context)
 
       copy.ModuleDef(mdef, mdef.mods, mdef.name, impl2) setType NoType
     }
@@ -2854,7 +2854,7 @@ trait Typers requires Analyzer {
         def improves(info1: ImplicitInfo, info2: ImplicitInfo) =
           (info2 == NoImplicitInfo) ||
           (info1 != NoImplicitInfo) &&
-          isStrictlyBetter(info1.tpe, info2.tpe)
+          isStrictlyBetterExpr(info1.tpe, info2.tpe)
         val shadowed = new HashSet[Name](8)
         def isApplicable(info: ImplicitInfo): boolean =
           !containsError(info.tpe) &&
diff --git a/src/library/scala/List.scala b/src/library/scala/List.scala
index 2fc06ecb62..18be4e308b 100644
--- a/src/library/scala/List.scala
+++ b/src/library/scala/List.scala
@@ -309,7 +309,7 @@ object List {
    *  for all corresponding elements of the argument lists.
    *
    *  @param p function to apply to each pair of elements.
-   *  @return  <code>n == 0 || (p(a<sub>0</sub>,b<sub>0</sub>) &amp;&amp;
+   *  @return  <code>(p(a<sub>0</sub>,b<sub>0</sub>) &amp;&amp;
    *           ... &amp;&amp; p(a<sub>n</sub>,b<sub>n</sub>))]</code>
    *           if the lists are <code>[a<sub>0</sub>, ..., a<sub>k</sub>]</code>;
    *           <code>[b<sub>0</sub>, ..., b<sub>l</sub>]</code>
@@ -740,6 +740,9 @@ sealed abstract class List[+A] extends Seq[A] {
     }
   }
 
+//  final def filterMap[B](f: PartialFunction[A, B]): List[B] =
+//    this filter f.isDefinedAt map f
+
   /** Removes all elements of the list which satisfy the predicate
    *  <code>p</code>. This is like <code>filter</code> with the
    *  predicate inversed.