removed warnings.. (hello guys)

7 files changed, 223 insertions, 197 deletions

diff --git a/src/compiler/scala/tools/nsc/doc/DocDriver.scala b/src/compiler/scala/tools/nsc/doc/DocDriver.scala
index 3ef6d0ca28..26b05d51ef 100644
--- a/src/compiler/scala/tools/nsc/doc/DocDriver.scala
+++ b/src/compiler/scala/tools/nsc/doc/DocDriver.scala
@@ -58,7 +58,7 @@ abstract class DocDriver extends ModelFrames with ModelToXML {
 
     for (p <- allClasses; d <- p._2) {
       symbols += d.sym
-      for (pp <- d.sym.tpe.parents) subClasses(pp.symbol) += d
+      for (pp <- d.sym.tpe.parents) subClasses(pp.typeSymbol) += d
     }
     additions0.init
     copyResources
@@ -220,39 +220,45 @@ abstract class DocDriver extends ModelFrames with ModelToXML {
     }
     return false;
   }
+
   def aref(href: String, label: String)(implicit frame: Frame) =
     frame.aref(href, "_self", label)
 
   protected def anchor(entity: Symbol)(implicit frame: Frame): NodeSeq =
     <a name={Text(frame.docName(entity))}></a>
 
-  object symbols extends jcl.LinkedHashSet[Symbol];
-  object allClasses extends jcl.LinkedHashMap[Package,jcl.LinkedHashSet[ClassOrObject]] {
-    override def default(pkg : Package) : jcl.LinkedHashSet[ClassOrObject] = {
-      object ret extends jcl.LinkedHashSet[ClassOrObject];
-      this(pkg) = ret; ret;
+  object symbols extends jcl.LinkedHashSet[Symbol]
+
+  object allClasses extends jcl.LinkedHashMap[Package, jcl.LinkedHashSet[ClassOrObject]] {
+    override def default(pkg: Package): jcl.LinkedHashSet[ClassOrObject] = {
+      object ret extends jcl.LinkedHashSet[ClassOrObject]
+      this(pkg) = ret
+      ret
     }
   }
-  object subClasses extends jcl.LinkedHashMap[Symbol,jcl.LinkedHashSet[ClassOrObject]] {
-    override def default(key : Symbol) = {
-      val ret = new jcl.LinkedHashSet[ClassOrObject];
-      this(key) = ret; ret;
+
+  object subClasses extends jcl.LinkedHashMap[Symbol, jcl.LinkedHashSet[ClassOrObject]] {
+    override def default(key: Symbol) = {
+      val ret = new jcl.LinkedHashSet[ClassOrObject]
+      this(key) = ret
+      ret
     }
   }
-  override def rootFor(sym : Symbol) : String = {
-    assert(sym != NoSymbol);
-    if (sym.toplevelClass == NoSymbol) return super.rootFor(sym);
-    if (symbols.contains(sym.toplevelClass)) return super.rootFor(sym);
-    val clazz = sym.toplevelClass.asInstanceOf[ClassSymbol];
+
+  override def rootFor(sym: Symbol): String = {
+    assert(sym != NoSymbol)
+    if (sym.toplevelClass == NoSymbol) return super.rootFor(sym)
+    if (symbols.contains(sym.toplevelClass)) return super.rootFor(sym)
+    val clazz = sym.toplevelClass.asInstanceOf[ClassSymbol]
     import scala.tools.nsc.io._;
     clazz.classFile match {
       case file : ZipArchive#FileEntry =>
-        val key = keyFor(file.archive);
+        val key = keyFor(file.archive)
         if (key != null && roots.contains(key)) {
-          return roots(key) + '/';
+          return roots(key) + '/'
         }
-      case _ => ;
+      case _ =>
     }
-    return super.rootFor(sym);
+    super.rootFor(sym)
   }
 }
diff --git a/src/compiler/scala/tools/nsc/doc/ModelExtractor.scala b/src/compiler/scala/tools/nsc/doc/ModelExtractor.scala
index 40a998be5a..47a267fec2 100644
--- a/src/compiler/scala/tools/nsc/doc/ModelExtractor.scala
+++ b/src/compiler/scala/tools/nsc/doc/ModelExtractor.scala
@@ -19,7 +19,7 @@ trait ModelExtractor {
   val global: Global
   import global._
 
-  def assert(b : Boolean) {
+  def assert(b: Boolean) {
     if (!b)
       throw new Error;
   }
@@ -108,7 +108,7 @@ trait ModelExtractor {
             sym.privateWithin.nameString;
           else null;
         });
-        def f(flag : Int, str : String) =
+        def f(flag: Int, str: String) =
           if (sym.hasFlag(flag)) string = string + " " + str;
 
         f(Flags.IMPLICIT, "implicit");
@@ -120,22 +120,21 @@ trait ModelExtractor {
         if (!sym.isTrait) f(Flags.DEFERRED, "abstract");
         string.trim;
     }
-    def listName = name;
-    def name = sym.nameString;
-    def fullName(sep : Char) = sym.fullNameString(sep);
-    def kind : String;
-    def header = {
-    }
-    def typeParams : List[TypeParam] = Nil
+    def listName = name
+    def name = sym.nameString
+    def fullName(sep: Char) = sym.fullNameString(sep)
+    def kind: String
+    def header { }
+    def typeParams: List[TypeParam] = Nil
     def params: List[List[Param]] = Nil
     def resultType: Option[Type] = None
     def parents: Iterable[Type] = Nil
     def lo: Option[Type] = sym.info match {
-      case TypeBounds(lo,hi) if decode(lo.symbol) != definitions.AllClass => Some(lo);
-      case _ => None;
+      case TypeBounds(lo,hi) if decode(lo.typeSymbol) != definitions.AllClass => Some(lo)
+      case _ => None
     }
     def hi : Option[Type] = sym.info match {
-      case TypeBounds(lo,hi) if decode(hi.symbol) != definitions.AnyClass => Some(hi)
+      case TypeBounds(lo,hi) if decode(hi.typeSymbol) != definitions.AnyClass => Some(hi)
       case _ => None
     }
     def variance = {
@@ -154,7 +153,7 @@ trait ModelExtractor {
   }
 
   class ConstructorParam(sym: Symbol) extends Param(sym) {
-    override protected def accessQualified(core : String, qual : String) = core match {
+    override protected def accessQualified(core: String, qual: String) = core match {
       case "public" => "val"
       case "protected" => super.accessQualified(core,qual) + " val"
       case "private" if qual == "this" => ""
@@ -203,7 +202,7 @@ trait ModelExtractor {
       pA = pA.tail;
       pB = pB.tail;
     }
-    return 0;
+    0
   }
 
   trait ClassOrObject extends Entity {
@@ -218,7 +217,7 @@ trait ModelExtractor {
       sym.constrParamAccessors.foreach(arg => {
         val str = symtab.Flags.flagsToString(arg.flags);
         assert(arg.hasFlag(symtab.Flags.PRIVATE) && arg.hasFlag(symtab.Flags.LOCAL));
-        val argName = arg.name.toString.trim;
+        val argName = arg.name.toString.trim
         val actual = sym.tpe.decls.elements.find(e => {
           val eName = e.name.toString.trim;
           argName == eName && {
@@ -238,41 +237,40 @@ trait ModelExtractor {
         }
       });
     }
-    def members0(f : Symbol => Boolean) = decls.projection.filterKeys(f).valueSet;
-    def members(c : Category) : Iterable[Member] = members0(c.f);
-    object inherited extends jcl.LinkedHashMap[Symbol,List[Member]]() {
-      override def default(tpe : Symbol) = Nil;
-      {
-        for (m <- sym.tpe.members if !sym.tpe.decls.elements.contains(m) &&
+    def members0(f: Symbol => Boolean) = decls.projection.filterKeys(f).valueSet
+    def members(c: Category): Iterable[Member] = members0(c.f)
+    object inherited extends jcl.LinkedHashMap[Symbol, List[Member]]() {
+      override def default(tpe: Symbol) = Nil
+      for (m <- sym.tpe.members if !sym.tpe.decls.elements.contains(m) &&
           (Values.f(m) || Methods.f(m))) {
-          val o = m.overridingSymbol(sym)
-          if ((o == NoSymbol)) {
-            val parent = decode(m.enclClass)
-            val mo = Member(m)
-            if (!mo.isEmpty) {
-              this(parent) = mo.get :: this(parent);
-            }
+        val o = m.overridingSymbol(sym)
+        if (o == NoSymbol) {
+          val parent = decode(m.enclClass)
+          val mo = Member(m)
+          if (!mo.isEmpty) {
+            this(parent) = mo.get :: this(parent);
           }
         }
       }
     }
-    override def parents = freshParents;
-    abstract class Member(sym : Symbol) extends Entity(sym) {
-      private def overriding = sym.allOverriddenSymbols;
+    override def parents = freshParents
+    abstract class Member(sym: Symbol) extends Entity(sym) {
+      private def overriding = sym.allOverriddenSymbols
       override def comment = super.comment match {
-      case ret @ Some(comment) => ret;
+      case ret @ Some(comment) =>
+        ret
       case None =>
-        val o = overriding.find(comments.contains);
-        o.map(comments.apply);
+        val o = overriding.find(comments.contains)
+        o.map(comments.apply)
       }
     }
     abstract class ValDef(sym: Symbol) extends Member(sym) {
-      override def resultType = Some(resultType0);
+      override def resultType = Some(resultType0)
       protected def resultType0: Type
       override def overridden: Iterable[Symbol] = {
-        var ret : jcl.LinkedHashSet[Symbol] = null;
+        var ret: jcl.LinkedHashSet[Symbol] = null
         for (parent <- ClassOrObject.this.parents) {
-          val sym0 = sym.overriddenSymbol(parent.symbol);
+          val sym0 = sym.overriddenSymbol(parent.typeSymbol)
           if (sym0 != NoSymbol) {
             if (ret == null) ret = new jcl.LinkedHashSet[Symbol];
             ret += sym0;
diff --git a/src/compiler/scala/tools/nsc/doc/ModelToXML.scala b/src/compiler/scala/tools/nsc/doc/ModelToXML.scala
index 31c59cd18a..ea47cbab0f 100644
--- a/src/compiler/scala/tools/nsc/doc/ModelToXML.scala
+++ b/src/compiler/scala/tools/nsc/doc/ModelToXML.scala
@@ -37,27 +37,28 @@ trait ModelToXML extends ModelExtractor {
       if (definitions.isFunctionType(tpe)) {
         val (args,r) = tpe.normalize.typeArgs.splitAt(tpe.normalize.typeArgs.length - 1);
         args.mkXML("(", ", ", ")")(link) ++ Text(" => ") ++ link(r.head);
-      } else if (tpe.symbol == definitions.RepeatedParamClass) {
-        assert(tpe.typeArgs.length == 1);
-        link(tpe.typeArgs(0)) ++ Text("*");
-      } else if (tpe.symbol == definitions.ByNameParamClass) {
-        assert(tpe.typeArgs.length == 1);
-        Text("=> ") ++ link(tpe.typeArgs(0));
-      } else if (tpe.symbol.name.toString.startsWith("Tuple") &&
-                 tpe.symbol.owner.name == nme.scala_.toTypeName) {
-        tpe.typeArgs.mkXML("(", ", ", ")")(link);
-      } else link(decode(tpe.symbol)) ++ tpe.typeArgs.surround("[", "]")(link);
+      } else if (tpe.typeSymbol == definitions.RepeatedParamClass) {
+        assert(tpe.typeArgs.length == 1)
+        link(tpe.typeArgs(0)) ++ Text("*")
+      } else if (tpe.typeSymbol == definitions.ByNameParamClass) {
+        assert(tpe.typeArgs.length == 1)
+        Text("=> ") ++ link(tpe.typeArgs(0))
+      } else if (tpe.typeSymbol.name.toString.startsWith("Tuple") &&
+                 tpe.typeSymbol.owner.name == nme.scala_.toTypeName) {
+        tpe.typeArgs.mkXML("(", ", ", ")")(link)
+      } else
+        link(decode(tpe.typeSymbol)) ++ tpe.typeArgs.surround("[", "]")(link)
     } else tpe match {
       case PolyType(tparams,result) =>
-        link(result) ++ tparams.surround("[", "]")(link);
+        link(result) ++ tparams.surround("[", "]")(link)
       case RefinedType(parents,_) =>
         val parents1 =
           if ((parents.length > 1) &&
-              (parents.head.symbol eq definitions.ObjectClass)) parents.tail;
+              (parents.head.typeSymbol eq definitions.ObjectClass)) parents.tail;
           else parents;
        parents1.mkXML(Text(""), <code> with </code>, Text(""))(link);
      case _ =>
-       link(decode(tpe.symbol))
+       link(decode(tpe.typeSymbol))
     }
   }
 
@@ -248,7 +249,7 @@ trait ModelToXML extends ModelExtractor {
     def attrFor(attr: AnnotationInfo): Node = {
       val buf = new StringBuilder
       val AnnotationInfo(tpe, args, nvPairs) = attr
-      val name = link(decode(tpe.symbol))
+      val name = link(decode(tpe.typeSymbol))
       if (!args.isEmpty)
         buf.append(args.mkString("(", ",", ")"))
       if (!nvPairs.isEmpty)
diff --git a/src/compiler/scala/tools/nsc/matching/CodeFactory.scala b/src/compiler/scala/tools/nsc/matching/CodeFactory.scala
index adedd1d19a..b3a2c34ece 100644
--- a/src/compiler/scala/tools/nsc/matching/CodeFactory.scala
+++ b/src/compiler/scala/tools/nsc/matching/CodeFactory.scala
@@ -1,5 +1,5 @@
 /* NSC -- new Scala compiler
- * Copyright 2005-2006 LAMP/EPFL
+ * Copyright 2005-2007 LAMP/EPFL
  * @author Burak Emir
  */
 // $Id$
@@ -8,7 +8,10 @@ package scala.tools.nsc.matching
 
 import scala.tools.nsc.util.Position
 
-/** contains many helper methods that build trees...some of these currently unused, since were for regexp matching
+/** contains many helper methods that build trees...some of these currently
+ *  unused, since were for regexp matching.
+ *
+ *  @author Burak Emir
  */
 trait CodeFactory {
   self: transform.ExplicitOuter =>
@@ -79,32 +82,32 @@ trait CodeFactory {
     var i = condition.length - 1
     while (i >= 0) {
       result = If(condition(i), body(i), result)
-      i = i - 1
+      i -= 1
     }
     result
   }
 
   final def renamingBind(defaultv: Set[Symbol], scrut: Symbol, ndefault: Tree) = {
-    if(!defaultv.isEmpty) {
-      var dv:List[Symbol] = Nil
-      var to:List[Symbol] = Nil
+    if (!defaultv.isEmpty) {
+      var dv: List[Symbol] = Nil
+      var to: List[Symbol] = Nil
       val it = defaultv.elements; while(it.hasNext) {
         dv = it.next :: dv
         to = scrut   :: to
       }
       val tss = new TreeSymSubstituter(dv, to)
-      tss.traverse( ndefault )
+      tss.traverse(ndefault)
     }
   }
 
   final def emptynessCheck(vsym: Symbol) = {
-    if(vsym.tpe.symbol == definitions.SomeClass)  // is Some[_]
+    if (vsym.tpe.typeSymbol == definitions.SomeClass)  // is Some[_]
       Literal(Constant(true))
     else                                          // is Option[_]
       Not(Select(Ident(vsym), nme.isEmpty))
   }
 
-  final def makeIf(cond:Tree, thenp:Tree, elsep:Tree) = cond match {
+  final def makeIf(cond: Tree, thenp: Tree, elsep: Tree) = cond match {
     case Literal(Constant(true)) => thenp
     case Literal(Constant(false)) => elsep
     case _ => If(cond, thenp, elsep)
@@ -142,7 +145,7 @@ trait CodeFactory {
   }
 
   /** for tree of sequence type, returns tree that drops first i elements */
-  final def seqDrop(sel:Tree, i: Int) = if(i == 0) sel else
+  final def seqDrop(sel:Tree, i: Int) = if (i == 0) sel else
     Apply(Select(Select(sel, "toList"), "drop"),
           List(Literal(Constant(i))))
 
@@ -283,31 +286,34 @@ trait CodeFactory {
     var nsubstituted = 0
     var nstatic = 0
 
-  final def squeezedBlock(vds:List[Tree], exp:Tree)(implicit theOwner: Symbol): Tree =
-    if(settings_squeeze)
+  final def squeezedBlock(vds: List[Tree], exp: Tree)(implicit theOwner: Symbol): Tree =
+    if (settings_squeeze)
       squeezedBlock1(vds, exp)
     else
       Block(vds,exp)
 
-  final def squeezedBlock1(vds:List[Tree], exp:Tree)(implicit theOwner: Symbol): Tree = {
+  final def squeezedBlock1(vds: List[Tree], exp: Tree)(implicit theOwner: Symbol): Tree = {
     val tpe = exp.tpe
-    class RefTraverser(sym:Symbol) extends Traverser {
+
+    class RefTraverser(sym: Symbol) extends Traverser {
       var nref = 0
       var nsafeRef = 0
       override def traverse(tree: Tree) = tree match {
         case t:Ident if t.symbol == sym =>
-          nref = nref + 1
+          nref += 1
           if(sym.owner == currentOwner)  { // oldOwner should match currentOwner
-            nsafeRef = nsafeRef + 1
+            nsafeRef += 1
           } /*else if(nref == 1) {
             Console.println("sym owner: "+sym.owner+" but currentOwner = "+currentOwner)
           }*/
-        case t if nref > 1 => // abort, no story to tell
-
-        case t       => super . traverse (t)
+        case t if nref > 1 =>
+          // abort, no story to tell
+        case t =>
+          super.traverse(t)
       }
     }
-    class Subst(sym:Symbol,rhs:Tree) extends Transformer {
+
+    class Subst(sym: Symbol, rhs: Tree) extends Transformer {
       var stop = false
       override def transform(tree: Tree) = tree match {
         case t:Ident if t.symbol == sym =>
@@ -315,28 +321,28 @@ trait CodeFactory {
           rhs
         case t if stop =>
           t
-        case t       =>
-          super . transform (t)
+        case t =>
+          super.transform(t)
       }
     }
     vds match {
-      case Nil   => exp
-
+      case Nil =>
+        exp
       case (vd:ValDef) :: rest =>
         // recurse
         val exp1 = squeezedBlock(rest, exp)
 
         //Console.println("squeezedBlock for valdef "+vd)
-        val sym  = vd.symbol
-        val rt   = new RefTraverser(sym)
+        val sym = vd.symbol
+        val rt = new RefTraverser(sym)
         rt.atOwner (theOwner) (rt.traverse(exp1))
         rt.nref match {
           case 0 =>
             nremoved = nremoved + 1
             exp1
           case 1 if rt.nsafeRef == 1 =>
-            nsubstituted = nsubstituted + 1
-            new Subst(sym, vd.rhs).transform( exp1 )
+            nsubstituted += 1
+            new Subst(sym, vd.rhs).transform(exp1)
           case _ =>
             exp1 match {
               case Block(vds2, exp2) => Block(vd::vds2, exp2)
diff --git a/src/compiler/scala/tools/nsc/matching/ParallelMatching.scala b/src/compiler/scala/tools/nsc/matching/ParallelMatching.scala
index b738e1a4a3..fea443fdb7 100644
--- a/src/compiler/scala/tools/nsc/matching/ParallelMatching.scala
+++ b/src/compiler/scala/tools/nsc/matching/ParallelMatching.scala
@@ -95,12 +95,12 @@ trait ParallelMatching  {
      if((column.length > 1) && isFlatCases(column)) {
        if(settings_debug) {
          Console.println("flat cases!"+column)
-         Console.println(scrutinee.tpe.symbol.children)
+         Console.println(scrutinee.tpe.typeSymbol.children)
          Console.println(scrutinee.tpe.member(nme.tag))
-         Console.println(column.map { x => x.tpe.symbol.tag })
+         Console.println(column.map { x => x.tpe.typeSymbol.tag })
        }
        return new MixCases(scrutinee, column, rest)
-       // if(scrutinee.tpe.symbol.hasFlag(symtab.Flags.SEALED)) new MixCasesSealed(scrutinee, column, rest)
+       // if(scrutinee.tpe.typeSymbol.hasFlag(symtab.Flags.SEALED)) new MixCasesSealed(scrutinee, column, rest)
        // else new MixCases(scrutinee, column, rest)
     }
     */
@@ -408,7 +408,7 @@ trait ParallelMatching  {
     private val patternType     = column.head match {
       case p @ (_:Ident | _:Select) =>
         singleType(p.symbol.tpe.prefix, p.symbol)  //ConstantType(p.tpe.singleton)
-      //case p@Apply(_,_) if !p.tpe.symbol.hasFlag(symtab.Flags.CASE) => ConstantType(new NamedConstant(p))
+      //case p@Apply(_,_) if !p.tpe.typeSymbol.hasFlag(symtab.Flags.CASE) => ConstantType(new NamedConstant(p))
       case _ => column.head.tpe
     }
     private val isCaseHead = patternType.typeSymbol.hasFlag(symtab.Flags.CASE)
@@ -517,7 +517,7 @@ trait ParallelMatching  {
       // succeeding => transition to translate(subsumed) (taking into account more specific)
       val nmatrix = {
         //Console.println("casted:"+casted)
-        //Console.println("casted.case:"+casted.tpe.symbol.hasFlag(symtab.Flags.CASE))
+        //Console.println("casted.case:"+casted.tpe.typeSymbol.hasFlag(symtab.Flags.CASE))
         var ntemps   = if(casted.tpe.typeSymbol.hasFlag(symtab.Flags.CASE)) casted.caseFieldAccessors map {
           meth =>
             val ctemp = newVar(scrutinee.pos, casted.tpe.memberType(meth).resultType)
@@ -647,7 +647,7 @@ trait ParallelMatching  {
 
       case mc: MixCases =>
         val (branches, defaultV, default) = mc.getTransition // tag body pairs
-        if(settings_debug) {
+        if (settings_debug) {
           Console.println("[[mix cases transition: branches \n"+(branches.mkString("","\n","")))
           Console.println("defaults:"+defaultV)
           Console.println(default)
@@ -807,7 +807,7 @@ object Rep {
               pats = (if (tpt.tpe <:< temp(j).tpe) p else typat)::pats
 
             case o @ Ident(n) =>
-                if(n != nme.WILDCARD) {
+                if (n != nme.WILDCARD) {
                   //Console.println("/'''''''''''' 1"+o.tpe)
                   //Console.println("/'''''''''''' 2"+o.symbol)
                   //Console.println("/'''''''''''' 3"+o.symbol.tpe)
@@ -815,42 +815,44 @@ object Rep {
                   //Console.println("/'''''''''''' 5"+o.symbol.tpe.prefix.isStable)
 
                   val stpe =
-                    if(o.tpe.symbol.isModule)
+                    if (o.tpe.typeSymbol.isModule)
                       singleType(o.tpe.prefix, o.symbol)
                     else
                       singleType(NoPrefix, o.symbol)
 
-                  val p    = Ident(nme.WILDCARD) setType stpe
-                  val q    = Typed(p, TypeTree(stpe)) setType stpe
+                  val p = Ident(nme.WILDCARD) setType stpe
+                  val q = Typed(p, TypeTree(stpe)) setType stpe
                   pats = q::pats
                 } else
                   pats = o::pats
 
-            case ua @ UnApply(Apply(fn,_),arg)             =>
+            case ua @ UnApply(Apply(fn, _), arg) =>
               fn.tpe match {
-              case MethodType(List(argtpe,_*),_) =>
-                pats = (if (temp(j).tpe <:< argtpe) ua else Typed(ua,TypeTree(argtpe)).setType(argtpe))::pats
+                case MethodType(List(argtpe,_*),_) =>
+                  pats = (if (temp(j).tpe <:< argtpe) ua else Typed(ua,TypeTree(argtpe)).setType(argtpe))::pats
               }
 
             /** something too tricky is going on if the outer types don't match
              */
-            case o @ Apply(app, List()) if !o.tpe.symbol.hasFlag(symtab.Flags.CASE) =>
+            case o @ Apply(app, List()) if !o.tpe.typeSymbol.hasFlag(symtab.Flags.CASE) =>
               //Console.println(o)
               //val stpe = singleType(NoPrefix, o.symbol)
-              val stpe = if(o.tpe.symbol.isModule) singleType(o.tpe.prefix, o.symbol) else mkThisType(o.symbol)
-              val p    = Ident(nme.WILDCARD) setType stpe
-              val q    = Typed(p, TypeTree(stpe)) setType stpe
+              val stpe =
+                if (o.tpe.typeSymbol.isModule) singleType(o.tpe.prefix, o.symbol)
+                else mkThisType(o.symbol)
+              val p = Ident(nme.WILDCARD) setType stpe
+              val q = Typed(p, TypeTree(stpe)) setType stpe
               pats = q::pats
 
             case p =>
               pats = p :: pats
           }
           opats = opats.tail
-          j = j + 1
+          j += 1
         }
         pats = pats.reverse
         //i = pats findIndexOf isAlternative
-        if(indexOfAlternative == -1)
+        if (indexOfAlternative == -1)
           List(Row(pats,subst,g,b))
         else {
           val prefix = pats.take( indexOfAlternative )
@@ -859,7 +861,7 @@ object Rep {
           alts map { p => Row(prefix ::: p :: suffix, subst, g, b) }
         }
     }
-    if(unchanged) {
+    if (unchanged) {
       val ri = RepImpl(temp,row).init
       //Console.println("ri = "+ri)
       ri
@@ -882,7 +884,7 @@ object Rep {
         //Console.println("sym! "+sym+" mutable? "+sym.hasFlag(symtab.Flags.MUTABLE)+" captured? "+sym.hasFlag(symtab.Flags.CAPTURED))
         if (sym.hasFlag(symtab.Flags.MUTABLE) &&  // indicates that have not yet checked exhaustivity
             !sym.hasFlag(symtab.Flags.CAPTURED) &&  // indicates @unchecked
-            sym.tpe.symbol.hasFlag(symtab.Flags.SEALED)) {
+            sym.tpe.typeSymbol.hasFlag(symtab.Flags.SEALED)) {
 
               sym.resetFlag(symtab.Flags.MUTABLE)
               sealedCols = i::sealedCols
@@ -893,7 +895,7 @@ object Rep {
                     val z = candidates(x)
                     if(x.hasFlag(symtab.Flags.ABSTRACT)) z else z + x
                   }
-              val cases = candidates(sym.tpe.symbol)
+              val cases = candidates(sym.tpe.typeSymbol)
               sealedComb = cases::sealedComb
             }
       }
@@ -901,8 +903,8 @@ object Rep {
       //  computes cartesian product, keeps indices available
       def combine(colcom: List[(Int,Set[Symbol])]): List[List[(Int,Symbol)]] = colcom match {
         case Nil => Nil
-        case (i,syms)::Nil  => syms.toList.map { sym => List((i,sym)) }
-        case (i,syms)::cs   => for (s <- syms.toList; rest <- combine(cs)) yield (i,s) :: rest
+        case (i,syms)::Nil => syms.toList.map { sym => List((i,sym)) }
+        case (i,syms)::cs  => for (s <- syms.toList; rest <- combine(cs)) yield (i,s) :: rest
       }
 
       if(!sealedCols.isEmpty) {
@@ -926,7 +928,7 @@ object Rep {
                   singleType(sym.tpe.prefix, sym.linkedModuleOfClass) // e.g. None, Nil
                 } else sym.tpe
                 //Console.print("covers: sym="+sym+" symtpe="+symtpe+" p="+p+", p.tpe="+p.tpe+" ?")
-                (p.tpe.symbol == sym) || (symtpe <:< p.tpe) ||
+                (p.tpe.typeSymbol == sym) || (symtpe <:< p.tpe) ||
                 /* outer, see scala.util.parsing.combinator.lexical.Scanner */
                 (p.tpe.prefix.memberType(sym) <:< p.tpe)
               }
@@ -964,7 +966,8 @@ object Rep {
     //def setParent(mr:MixTypes): this.type = { mixtureParent = mr; this }
 
     final def applyRule: RuleApplication = row match {
-      case Nil            => ErrorRule
+      case Nil =>
+        ErrorRule
       case Row(pats,subst,g,b)::xs =>
         if(pats forall isDefaultPattern) {
           val subst1 = pats.zip(temp) flatMap {
@@ -1004,10 +1007,10 @@ object Rep {
 
   /** creates initial clause matrix
    */
-  final def initRep(selector:Tree, cases:List[Tree], checkExhaustive: Boolean)(implicit theOwner: Symbol) = {
+  final def initRep(selector: Tree, cases: List[Tree], checkExhaustive: Boolean)(implicit theOwner: Symbol) = {
     val root = newVar(selector.pos, selector.tpe)
     // communicate whether exhaustiveness-checking is enabled via some flag
-    if(!checkExhaustive)
+    if (!checkExhaustive)
       root.setFlag(symtab.Flags.CAPTURED)
     val row  = cases map { case CaseDef(pat,g,b) => Row(List(pat), Nil, g, b) }
     Rep(List(root), row)
@@ -1031,9 +1034,9 @@ object Rep {
    *  @param   x a pattern
    *  @return  vs variables bound, p pattern proper
    */
-  final def strip(x:Tree): (Set[Symbol], Tree) = x match {
-    case b @ Bind(_,pat) => val (vs,p) = strip(pat); (vs + b.symbol, p)
-    case z               => (emptySymbolSet,z)
+  final def strip(x: Tree): (Set[Symbol], Tree) = x match {
+    case b @ Bind(_,pat) => val (vs, p) = strip(pat); (vs + b.symbol, p)
+    case z               => (emptySymbolSet, z)
   }
 
   final def strip1(x:Tree): Set[Symbol] = x match { // same as strip(x)._1
@@ -1054,25 +1057,25 @@ object Rep {
   final def newVar(pos: Position, name: Name, tpe: Type)(implicit theOwner: Symbol): Symbol = {
     if(tpe eq null) assert(tpe ne null, "newVar("+name+", null)")
     val sym = theOwner.newVariable(pos, name) // careful: pos has special meaning
-    sym.setFlag(symtab.Flags.TRANS_FLAG)
-    sym.setInfo(tpe)
+    sym setFlag symtab.Flags.TRANS_FLAG
+    sym setInfo tpe
     sym
   }
 
   final def newVar(pos: Position, tpe: Type)(implicit theOwner: Symbol): Symbol =
-    newVar(pos, cunit.fresh.newName("temp"), tpe).setFlag(symtab.Flags.SYNTHETIC)
+    newVar(pos, cunit.fresh.newName("temp"), tpe) setFlag symtab.Flags.SYNTHETIC
 
   /** returns the condition in "if(cond) k1 else k2"
    */
   final def condition(tpe: Type, scrut: Symbol): Tree = {
     val res = condition1(tpe, scrut)
-    if(true && settings_debug)
+    if (settings_debug)
       Console.println("condition, tpe = "+tpe+", scrut.tpe = "+scrut.tpe+", res = "+res)
     res
   }
   final def condition1(tpe: Type, scrut: Symbol): Tree = {
-    assert (scrut ne NoSymbol)
-    condition(tpe, Ident(scrut) . setType (scrut.tpe) . setSymbol (scrut))
+    assert(scrut ne NoSymbol)
+    condition(tpe, Ident(scrut) setType scrut.tpe setSymbol scrut)
   }
 
   final def condition(tpe: Type, scrutineeTree: Tree): Tree = {
@@ -1081,23 +1084,23 @@ object Rep {
     //Console.println("tpe = "+tpe+" prefix="+tpe.prefix)
     //Console.println("singletontype?"+tpe.isInstanceOf[SingletonType])
     //Console.println("constanttype? "+tpe.isInstanceOf[ConstantType])
-    //Console.println("value         "+tpe.symbol.isValue)
-    //Console.println("module        "+tpe.symbol.isModule)
+    //Console.println("value         "+tpe.typeSymbol.isValue)
+    //Console.println("module        "+tpe.typeSymbol.isModule)
     if (tpe.isInstanceOf[SingletonType] && !tpe.isInstanceOf[ConstantType]) {
 
-      if(tpe.symbol.isModule) {// object
+      if (tpe.typeSymbol.isModule) {// object
         if (scrutineeTree.tpe <:< definitions.AnyRefClass.tpe)
-          Eq(gen.mkAttributedRef(tpe.symbol), scrutineeTree)             // object
+          Eq(gen.mkAttributedRef(tpe.typeSymbol), scrutineeTree)             // object
         else
-          Equals(gen.mkAttributedRef(tpe.symbol), scrutineeTree)             // object
+          Equals(gen.mkAttributedRef(tpe.typeSymbol), scrutineeTree)             // object
       } else {
         //Console.print("111 ??")
         //Console.println("tpe stable         "+tpe.isStable)
         //Console.println("tpe prefix stable  "+tpe.prefix.isStable)
-        //val x = Equals(Apply(gen.mkAttributedRef(tpe.symbol), List()), scrutineeTree)
+        //val x = Equals(Apply(gen.mkAttributedRef(tpe.typeSymbol), List()), scrutineeTree)
         val x =
           if(tpe.prefix ne NoPrefix) gen.mkIsInstanceOf(scrutineeTree, tpe)
-          else Equals(gen.mkAttributedRef(tpe.symbol), scrutineeTree)
+          else Equals(gen.mkAttributedRef(tpe.typeSymbol), scrutineeTree)
         //Console.println(" = "+x)
         typed { x }
       }
@@ -1111,51 +1114,54 @@ object Rep {
         Eq(scrutineeTree, Literal(value))             // constant
       else
         Equals(scrutineeTree, Literal(value))             // constant
-    } else if(scrutineeTree.tpe <:< tpe && tpe <:< definitions.AnyRefClass.tpe) {
+    } else if (scrutineeTree.tpe <:< tpe && tpe <:< definitions.AnyRefClass.tpe) {
       //if(scrutineeTree.symbol.hasFlag(symtab.Flags.SYNTHETIC)) Literal(Constant(true)) else
       NotNull(scrutineeTree)
-    } else if(tpe.prefix.symbol.isTerm && tpe.symbol.linkedModuleOfClass != NoSymbol) { // object
+    } else if(tpe.prefix.typeSymbol.isTerm && tpe.typeSymbol.linkedModuleOfClass != NoSymbol) { // object
       //Console.println("iT"+tpe.prefix.symbol.isTerm)
-      //Console.println("lmoc"+tpe.symbol.linkedModuleOfClass)
-      Eq(gen.mkAttributedRef(tpe.prefix, tpe.symbol.linkedModuleOfClass), scrutineeTree)
+      //Console.println("lmoc"+tpe.typeSymbol.linkedModuleOfClass)
+      Eq(gen.mkAttributedRef(tpe.prefix, tpe.typeSymbol.linkedModuleOfClass), scrutineeTree)
     } else
       //Console.println(tpe.prefix.symbol.isTerm)
-      //Console.println(tpe.symbol)
-      //Console.println(tpe.symbol.linkedModuleOfClass)
+      //Console.println(tpe.typeSymbol)
+      //Console.println(tpe.typeSymbol.linkedModuleOfClass)
       gen.mkIsInstanceOf(scrutineeTree, tpe)
   }
 
-  final def needsOuterTest(tpe2test:Type, scrutinee:Type) = tpe2test.normalize match {
+  final def needsOuterTest(tpe2test: Type, scrutinee: Type) = tpe2test.normalize match {
     case TypeRef(prefix,_,_) =>
-      prefix.symbol.isTerm &&
-    !prefix.symbol.isPackage &&
-      outerAlwaysEqual(tpe2test,scrutinee) == Some(false)
-    case _ => false
+      prefix.typeSymbol.isTerm &&
+      !prefix.typeSymbol.isPackage &&
+      outerAlwaysEqual(tpe2test, scrutinee) == Some(false)
+    case _ =>
+     false
   }
 
   /** returns a result if both are TypeRefs, returns Some(true) if left and right are statically known to have
    *  the same outer, i.e. if their prefixes are the same
    */
-  final def outerAlwaysEqual(left: Type, right: Type): Option[Boolean] = (left.normalize,right.normalize) match {
-    case (TypeRef(lprefix, _,_), TypeRef(rprefix,_,_)) =>
-      if(!(lprefix =:= rprefix)) {
-        //DEBUG("DEBUG(outerAlwaysEqual) Some(f) for"+(left,right))
-      }
-      Some(lprefix =:= rprefix)
-    case _                                             => None
-  }
+  final def outerAlwaysEqual(left: Type, right: Type): Option[Boolean] =
+    (left.normalize, right.normalize) match {
+      case (TypeRef(lprefix, _, _), TypeRef(rprefix, _, _)) =>
+        //if(!(lprefix =:= rprefix)) {
+          //DEBUG("DEBUG(outerAlwaysEqual) Some(f) for"+(left,right))
+        //}
+        Some(lprefix =:= rprefix)
+      case _ =>
+        None
+    }
 
   /** adds a test comparing the dynamic outer to the static outer */
   final def addOuterCondition(cond:Tree, tpe2test: Type, scrutinee: Tree, handleOuter: Tree=>Tree) = {
     val TypeRef(prefix,_,_) = tpe2test
-    var theRef = gen.mkAttributedRef(prefix.prefix, prefix.symbol)
+    var theRef = gen.mkAttributedRef(prefix.prefix, prefix.typeSymbol)
 
     // needs explicitouter treatment
     theRef = handleOuter(theRef)
 
-    val outerAcc = outerAccessor(tpe2test.symbol)
+    val outerAcc = outerAccessor(tpe2test.typeSymbol)
     if (outerAcc == NoSymbol) {
-      if (settings_debug) cunit.warning(scrutinee.pos, "no outer acc for "+tpe2test.symbol)
+      if (settings_debug) cunit.warning(scrutinee.pos, "no outer acc for "+tpe2test.typeSymbol)
       cond
     } else
       And(cond,
diff --git a/src/compiler/scala/tools/nsc/matching/PatternMatchers.scala b/src/compiler/scala/tools/nsc/matching/PatternMatchers.scala
index 6585e02f35..b6b483ae5f 100644
--- a/src/compiler/scala/tools/nsc/matching/PatternMatchers.scala
+++ b/src/compiler/scala/tools/nsc/matching/PatternMatchers.scala
@@ -60,7 +60,7 @@ trait PatternMatchers { self: transform.ExplicitOuter with PatternNodes with Par
       this.doCheckExhaustive = doCheckExhaustive
       this.selector = selector
       this.handleOuter = handleOuter
-      if(settings_debug) {
+      if (settings_debug) {
         Console.println("****")
         Console.println("**** initalize, selector = "+selector+" selector.tpe = "+selector.tpe)
         Console.println("****    doCheckExhaustive == "+doCheckExhaustive)
@@ -239,18 +239,20 @@ trait PatternMatchers { self: transform.ExplicitOuter with PatternNodes with Par
       //Console.println("isImplemented? "+x)
       x match {
         case app @ Apply(fn,xs) =>
-          if(!app.tpe.symbol.hasFlag(symtab.Flags.CASE) /*|| (fn.symbol ne null)*/) CantHandleApply else {
-          /*if(!app.tpe.symbol.hasFlag(symtab.Flags.CASE)) {
-            Console.print("what is this?"+x)
-            if(fn.symbol eq null) {
-              Console.println("it's fn doesn't even have a symbol?!")
-            } else {
-              Console.println("it's fn symbol is "+fn.symbol)
-            }
-          }*/
-          isImplemented(xs)
+          if(!app.tpe.typeSymbol.hasFlag(symtab.Flags.CASE) /*|| (fn.symbol ne null)*/)
+            CantHandleApply
+          else {
+            /*if(!app.tpe.symbol.hasFlag(symtab.Flags.CASE)) {
+              Console.print("what is this?"+x)
+              if(fn.symbol eq null) {
+                Console.println("it's fn doesn't even have a symbol?!")
+              } else {
+                Console.println("it's fn symbol is "+fn.symbol)
+              }
+            }*/
+            isImplemented(xs)
           }
-        case p @ Ident(n)           => null // if(n!= nme.WILDCARD && p.symbol.) CantHandleIdent else null
+        case p @ Ident(n)       => null // if(n!= nme.WILDCARD && p.symbol.) CantHandleIdent else null
         case _:ArrayValue       => CantHandleSeq
         case UnApply(fn,xs)     => isImplemented(xs)
         case Bind(n, p)         => isImplemented(p)
@@ -349,12 +351,12 @@ trait PatternMatchers { self: transform.ExplicitOuter with PatternNodes with Par
     //Console.println("tree.tpe "+tree.tpe);
     //Console.println("tree.getClass() "+tree.getClass());
     val t = tree match {
-      case Bind(name, Typed(Ident( nme.WILDCARD ), tpe)) => // x@_:Type
+      case Bind(name, Typed(Ident(nme.WILDCARD), tpe)) => // x@_:Type
         // @note: safest! typer does not always use tpe.tpe, e.g. in the case of refinement type tests
         val tpe2test = tree.symbol.tpe
         // @note: if (isSubType(header.tpe, tpe2test)) then this will be translated to isNull test
         val node = pConstrPat(tree.pos, tpe2test)
-        env.newBoundVar( tree.symbol, tpe2test, typed(Ident( node.casted )));
+        env.newBoundVar(tree.symbol, tpe2test, typed(Ident(node.casted)));
         node
 
       case Bind(name, Ident(nme.WILDCARD)) => // x @ _
@@ -387,7 +389,7 @@ trait PatternMatchers { self: transform.ExplicitOuter with PatternNodes with Par
                 if(isRightIgnoring(av)) {
                   //Console.println(av.toString()+" IS RIGHTIGNORING");
                   val castedRest = ts.last match {
-                    case b:Bind => b.symbol;
+                    case b:Bind => b.symbol
                     case _      => null
                   }
                   pRightIgnoringSequencePat(tree.pos, tree.tpe, castedRest, ts.length-1);
@@ -516,13 +518,13 @@ trait PatternMatchers { self: transform.ExplicitOuter with PatternNodes with Par
     } else {
       //Console.println("NOT FIRSTPOS");
       //Console.println("newHeader :: ");
-      if(!casted.tpe.symbol.hasFlag(Flags.CASE)) {
+      if (!casted.tpe.typeSymbol.hasFlag(Flags.CASE)) {
 
         //Console.println("NOT CASE");
         //Console.println("getProductArgs? "+defs.getProductArgs(casted.tpe));
         defs.getProductArgs(casted.tpe) match  {
           case Some(targs) =>
-            val accSym = defs.productProj(casted.tpe.symbol, index+1)
+            val accSym = defs.productProj(casted.tpe.typeSymbol, index+1)
             val accTree = typed(Apply(Select(ident, accSym), List())) // nsc !
             return pHeader(pos, accTree.tpe, accTree)
           case None =>
@@ -541,8 +543,8 @@ print()
 
       //Console.println("CASE");
 
-      val caseAccs = casted.tpe.symbol.caseFieldAccessors;
-      if (caseAccs.length <= index) Console.println("selecting " + index + " in case fields of " + casted.tpe.symbol + "=" + casted.tpe.symbol.caseFieldAccessors);//debug
+      val caseAccs = casted.tpe.typeSymbol.caseFieldAccessors;
+      if (caseAccs.length <= index) Console.println("selecting " + index + " in case fields of " + casted.tpe.typeSymbol + "=" + casted.tpe.typeSymbol.caseFieldAccessors);//debug
       val ts = caseAccs(index);
       val accTree = typed(Apply(Select(ident, ts), List()))
       val accType = accTree.tpe
@@ -624,8 +626,8 @@ print()
 /* first try at exhaust improvement
          selectorMap.update((casted, curHeader.selector.symbol),
            selectorMap.get(casted, curHeader.selector.symbol) match {
-            case Some(xs) =>  pat.tpe.symbol::xs
-            case _ => pat.tpe.symbol::Nil
+            case Some(xs) =>  pat.tpe.typeSymbol::xs
+            case _ => pat.tpe.typeSymbol::Nil
           })
 */
           if (bodycond ne null) target.and = bodycond(target.and) // restores body with the guards
@@ -709,7 +711,7 @@ print()
     protected def nCaseComponents(tree: Tree): int = {
       tree match {
         case Apply(fn, _) =>
-          val tpe = tree.tpe.symbol.primaryConstructor.tpe
+          val tpe = tree.tpe.typeSymbol.primaryConstructor.tpe
           //Console.println("~~~ " + tree.type() + ", " + tree.type().symbol.primaryConstructor());
           tpe match {
             // I'm not sure if this is a good idea, but obviously, currently all case classes
@@ -1070,15 +1072,15 @@ print()
       while (node ne null)
       node match {
         case ConstrPat(casted) =>
-          cases = insertNode(node.tpe.symbol.tag, node, cases)
+          cases = insertNode(node.tpe.typeSymbol.tag, node, cases)
           node = node.or
 
         case DefaultPat() =>
           defaultCase = node
           node = node.or
 
-        case VariablePat(tree) if node.tpe.symbol.hasFlag(Flags.CASE) =>
-          cases = insertNode(node.tpe.symbol.tag, node, cases)
+        case VariablePat(tree) if node.tpe.typeSymbol hasFlag Flags.CASE =>
+          cases = insertNode(node.tpe.typeSymbol.tag, node, cases)
           node = node.or
 
         case _ =>
@@ -1146,7 +1148,7 @@ print()
           case DefaultPat() =>
             return toTree(node.and);
 
-          case UnapplyPat(casted, Apply(fn1, appargs)) if casted.tpe.symbol == defs.BooleanClass => // special case
+          case UnapplyPat(casted, Apply(fn1, appargs)) if casted.tpe.typeSymbol == defs.BooleanClass => // special case
             var useSelector = selector
             val checkType = fn1.tpe match {
               case MethodType(List(argtpe,_*),_) =>
@@ -1218,7 +1220,7 @@ print()
                 // needs explicitouter treatment
                 theRef = handleOuter(theRef)
 
-                val outerAcc = outerAccessor(casted.tpe.symbol)
+                val outerAcc = outerAccessor(casted.tpe.typeSymbol)
 
                 if(outerAcc != NoSymbol) { // some guys don't have outers
                   cond = And(cond,
@@ -1288,13 +1290,13 @@ print()
                 Literal(Constant(true))
 
             val treeAsSeq =
-              if(!isSubType(selector.tpe,ntpe))
+              if (!isSubType(selector.tpe,ntpe))
                 typed(gen.mkAsInstanceOf(selector.duplicate, ntpe, true))
               else
                 selector.duplicate
 
             val cond =
-              if(minlen == 0) tpetest
+              if (minlen == 0) tpetest
               else And(tpetest, seqLongerThan(treeAsSeq, ntpe, minlen))
 
             var bindings =
@@ -1320,11 +1322,11 @@ print()
 
           case VariablePat(tree) =>
             // objects are compared by eq, not ==
-            val cmp = if(tree.tpe.symbol.isModuleClass && selector.tpe <:< defs.AnyRefClass.tpe)
+            val cmp = if (tree.tpe.typeSymbol.isModuleClass && selector.tpe <:< defs.AnyRefClass.tpe)
                         Eq(selector.duplicate, tree)
                       else
                         Equals(selector.duplicate, tree)
-            return myIf( cmp,
+            return myIf(cmp,
                       toTree(node.and),
                       toTree(node.or, selector.duplicate));
 
@@ -1333,7 +1335,7 @@ print()
                       toTree(node.and),
                       toTree(node.or, selector.duplicate));
           case _ =>
-            scala.Predef.error("cannot handle pattern:"+node);
+            scala.Predef.error("cannot handle pattern:"+node)
         }
     }
   }
diff --git a/src/library/scala/util/parsing/combinator/lexical/Scanners.scala b/src/library/scala/util/parsing/combinator/lexical/Scanners.scala
index 8585b4d677..ff17ea7f63 100644
--- a/src/library/scala/util/parsing/combinator/lexical/Scanners.scala
+++ b/src/library/scala/util/parsing/combinator/lexical/Scanners.scala
@@ -57,8 +57,15 @@ trait Scanners extends Parsers with Tokens {
         token(in1) match {
           case Success(tok, in2) => Triple(tok, in1, in2)
           case ns: NoSuccess => Triple(errorToken(ns.msg), ns.next, skip(ns.next))
+          case Failure(_, in2) => error("internal error")
+          case Error(_, in2) => error("internal error")
         }
-      case ns: NoSuccess => Triple(errorToken(ns.msg), ns.next, skip(ns.next))
+      case ns: NoSuccess =>
+        Triple(errorToken(ns.msg), ns.next, skip(ns.next))
+      case Failure(_, in1) =>
+        error("internal error")
+      case Error(_, in1) =>
+        error("internal error")
     }
     private def skip(in: Reader[Char]) = if (in.atEnd) in else in.rest