Made some cosmetic but clarity-increasing chang...

Made some cosmetic but clarity-increasing changes to a few files.
Primarily, used corresponds where possible rather than zipped.forall.
Added isImplicit and isJava to MethodType so the relevant subtypes
could be determined without the hideous isInstanceOf checks. Review by
odersky.

11 files changed, 84 insertions, 88 deletions

diff --git a/src/compiler/scala/tools/nsc/backend/icode/TypeStacks.scala b/src/compiler/scala/tools/nsc/backend/icode/TypeStacks.scala
index 1e943529b2..6872f56c39 100644
--- a/src/compiler/scala/tools/nsc/backend/icode/TypeStacks.scala
+++ b/src/compiler/scala/tools/nsc/backend/icode/TypeStacks.scala
@@ -76,8 +76,7 @@ trait TypeStacks { self: ICodes =>
      * types agree if one is a subtype of the other.
      */
     def agreesWith(other: TypeStack): Boolean =
-      (types.length == other.types.length) &&
-      ((types, other.types).zipped forall ((t1, t2) => t1 <:< t2 || t2 <:< t1))
+      (types corresponds other.types)((t1, t2) => t1 <:< t2 || t2 <:< t1)
 
     /* This method returns a String representation of the stack */
     override def toString() = types.mkString("\n", "\n", "\n")
diff --git a/src/compiler/scala/tools/nsc/backend/icode/analysis/CopyPropagation.scala b/src/compiler/scala/tools/nsc/backend/icode/analysis/CopyPropagation.scala
index 5ba5f684f7..b0fef79fa4 100644
--- a/src/compiler/scala/tools/nsc/backend/icode/analysis/CopyPropagation.scala
+++ b/src/compiler/scala/tools/nsc/backend/icode/analysis/CopyPropagation.scala
@@ -58,18 +58,13 @@ abstract class CopyPropagation {
 
     class State(val bindings: Bindings, var stack: List[Value]) {
       override def equals(that: Any): Boolean =
-        (this eq that.asInstanceOf[AnyRef]) ||
-        that.isInstanceOf[State] && {
-          val other = that.asInstanceOf[State]
-
+        (this eq that.asInstanceOf[AnyRef]) || (that match {
           /* comparison with bottom is reference equality! */
-          if ((other eq bottom) || (this eq bottom))
-            (this eq other)
-          else {
+          case other: State if (this ne bottom) && (other ne bottom) =>
             (this.bindings == other.bindings) &&
-            ((this.stack, other.stack).zipped forall (_ == _))
-          }
-        }
+            (this.stack corresponds other.stack)(_ == _)  // @PP: corresponds
+          case _ => false
+        })
 
       /* Return an alias for the given local. It returns the last
        * local in the chain of aliased locals. Cycles are not allowed
diff --git a/src/compiler/scala/tools/nsc/dependencies/Changes.scala b/src/compiler/scala/tools/nsc/dependencies/Changes.scala
index 43efd0726b..530519b148 100644
--- a/src/compiler/scala/tools/nsc/dependencies/Changes.scala
+++ b/src/compiler/scala/tools/nsc/dependencies/Changes.scala
@@ -88,13 +88,12 @@ abstract class Changes {
       }
       sameTypes(parents1, parents2) && isSubScope(ref1, ref2) && isSubScope(ref2, ref1)
 
-    case (MethodType(params1, res1), MethodType(params2, res2)) =>
+    case (mt1 @ MethodType(params1, res1), mt2 @ MethodType(params2, res2)) =>
       // new dependent types: probably fix this, use substSym as done for PolyType
       (sameTypes(tp1.paramTypes, tp2.paramTypes) &&
-      ((tp1.params, tp2.params).zipped forall ((t1, t2) =>
-        (sameSymbol(t1, t2) && sameFlags(t1, t2)))) &&
+      (tp1.params corresponds tp2.params)((t1, t2) => sameSymbol(t1, t2) && sameFlags(t1, t2)) && // @PP: corresponds
       sameType(res1, res2) &&
-      tp1.isInstanceOf[ImplicitMethodType] == tp2.isInstanceOf[ImplicitMethodType])
+      mt1.isImplicit == mt2.isImplicit)
 
     case (PolyType(tparams1, res1), PolyType(tparams2, res2)) =>
       sameTypeParams(tparams1, tparams2) && sameType(res1, res2)
@@ -136,8 +135,7 @@ abstract class Changes {
     sameTypes(tparams1 map (_.info), tparams2 map (_.info)) &&
     sameTypes(tparams1 map (_.tpe), tparams2 map (_.tpe))
 
-  def sameTypes(tps1: List[Type], tps2: List[Type]): Boolean =
-    (tps1.length == tps2.length) && ((tps1, tps2).zipped forall sameType)
+  def sameTypes(tps1: List[Type], tps2: List[Type]) = (tps1 corresponds tps2)(sameType)
 
   /** Return the list of changes between 'from' and 'toSym.info'.
    */
diff --git a/src/compiler/scala/tools/nsc/symtab/Types.scala b/src/compiler/scala/tools/nsc/symtab/Types.scala
index c1f4115a88..aa2ab5e572 100644
--- a/src/compiler/scala/tools/nsc/symtab/Types.scala
+++ b/src/compiler/scala/tools/nsc/symtab/Types.scala
@@ -1824,6 +1824,13 @@ A type's typeSymbol should never be inspected directly.
     override val isTrivial: Boolean =
       params.forall(_.tpe.isTrivial) && resultType.isTrivial
 
+    // The comment at ImplicitMethodType says the class is no longer needed,
+    // "a method type is implicit if the first parameter has the IMPLICIT flag".
+    // Should that change be pursued, then this method should be:
+    // def isImplicit = vparams.nonEmpty && (vparams.head hasFlag IMPLICIT)
+    def isImplicit = false
+    def isJava = false
+
     //assert(paramTypes forall (pt => !pt.typeSymbol.isImplClass))//DEBUG
     override def paramSectionCount: Int = resultType.paramSectionCount + 1
 
@@ -1868,9 +1875,13 @@ A type's typeSymbol should never be inspected directly.
 
   // todo: this class is no longer needed, a method type is implicit if the first
   // parameter has the IMPLICIT flag
-  class ImplicitMethodType(ps: List[Symbol], rt: Type) extends MethodType(ps, rt)
+  class ImplicitMethodType(ps: List[Symbol], rt: Type) extends MethodType(ps, rt) {
+    override def isImplicit = true
+  }
 
-  class JavaMethodType(ps: List[Symbol], rt: Type) extends MethodType(ps, rt)
+  class JavaMethodType(ps: List[Symbol], rt: Type) extends MethodType(ps, rt) {
+    override def isJava = true
+  }
 
   /** A class representing a polymorphic type or, if tparams.length == 0,
    *  a parameterless method type.
@@ -3856,18 +3867,14 @@ A type's typeSymbol should never be inspected directly.
         // new dependent types: probably fix this, use substSym as done for PolyType
         (isSameTypes(tp1.paramTypes, tp2.paramTypes) &&
          res1 =:= res2 &&
-         tp1.isInstanceOf[ImplicitMethodType] == tp2.isInstanceOf[ImplicitMethodType])
+         tp1.isImplicit == tp2.isImplicit)
       case (PolyType(tparams1, res1), PolyType(tparams2, res2)) =>
-//        assert((tparams1 map (_.typeParams.length)) == (tparams2 map (_.typeParams.length)))
-        (tparams1.length == tparams2.length &&
-         (tparams1, tparams2).zipped.forall
-           ((p1, p2) => p1.info =:= p2.info.substSym(tparams2, tparams1)) && //@M looks like it might suffer from same problem as #2210
-         res1 =:= res2.substSym(tparams2, tparams1))
+        // assert((tparams1 map (_.typeParams.length)) == (tparams2 map (_.typeParams.length)))
+        (tparams1 corresponds tparams2)(_.info =:= _.info.substSym(tparams2, tparams1)) && // @M looks like it might suffer from same problem as #2210
+          res1 =:= res2.substSym(tparams2, tparams1)
       case (ExistentialType(tparams1, res1), ExistentialType(tparams2, res2)) =>
-        (tparams1.length == tparams2.length &&
-         (tparams1, tparams2).zipped.forall
-           ((p1, p2) => p1.info =:= p2.info.substSym(tparams2, tparams1)) && //@M looks like it might suffer from same problem as #2210
-         res1 =:= res2.substSym(tparams2, tparams1))
+        (tparams1 corresponds tparams2)(_.info =:= _.info.substSym(tparams2, tparams1)) && // @M looks like it might suffer from same problem as #2210
+          res1 =:= res2.substSym(tparams2, tparams1)
       case (TypeBounds(lo1, hi1), TypeBounds(lo2, hi2)) =>
         lo1 =:= lo2 && hi1 =:= hi2
       case (BoundedWildcardType(bounds), _) =>
@@ -3981,26 +3988,28 @@ A type's typeSymbol should never be inspected directly.
             // new dependent types: probably fix this, use substSym as done for PolyType
             return isSameTypes(mt1.paramTypes, mt2.paramTypes) &&
               mt1.resultType =:= mt2.resultType &&
-              tp1.isInstanceOf[ImplicitMethodType] == tp2.isInstanceOf[ImplicitMethodType]
+              mt1.isImplicit == mt2.isImplicit
           case _ =>
         }
       case PolyType(tparams1, res1) =>
         tp2 match {
           case PolyType(tparams2, res2) =>
 //            assert((tparams1 map (_.typeParams.length)) == (tparams2 map (_.typeParams.length)))
-            return tparams1.length == tparams2.length &&
-              (tparams1, tparams2).zipped.forall((p1, p2) =>
-                p1.info =:= p2.info.substSym(tparams2, tparams1)) && //@M looks like it might suffer from same problem as #2210
-              res1 =:= res2.substSym(tparams2, tparams1)
+              // @M looks like it might suffer from same problem as #2210
+              return (
+                (tparams1 corresponds tparams2)(_.info =:= _.info.substSym(tparams2, tparams1)) &&
+                res1 =:= res2.substSym(tparams2, tparams1)
+              )
           case _ =>
         }
       case ExistentialType(tparams1, res1) =>
         tp2 match {
           case ExistentialType(tparams2, res2) =>
-            return (tparams1.length == tparams2.length &&
-               (tparams1, tparams2).zipped.forall
-               ((p1, p2) => p1.info =:= p2.info.substSym(tparams2, tparams1)) && //@M looks like it might suffer from same problem as #2210
-               res1 =:= res2.substSym(tparams2, tparams1))
+            // @M looks like it might suffer from same problem as #2210
+            return (
+              (tparams1 corresponds tparams2)(_.info =:= _.info.substSym(tparams2, tparams1)) &&
+              res1 =:= res2.substSym(tparams2, tparams1)
+            )
           case _ =>
         }
       case TypeBounds(lo1, hi1) =>
@@ -4064,8 +4073,7 @@ A type's typeSymbol should never be inspected directly.
   /** Are `tps1' and `tps2' lists of pairwise equivalent
    *  types?
    */
-  def isSameTypes(tps1: List[Type], tps2: List[Type]): Boolean =
-    tps1.length == tps2.length && ((tps1, tps2).zipped forall (_ =:= _))
+  def isSameTypes(tps1: List[Type], tps2: List[Type]): Boolean = (tps1 corresponds tps2)(_ =:= _)
 
   private var pendingSubTypes = new collection.mutable.HashSet[SubTypePair]
   private var basetypeRecursions: Int = 0
@@ -4145,18 +4153,17 @@ A type's typeSymbol should never be inspected directly.
     ((tp1.normalize, tp2.normalize) match {
       case (PolyType(tparams1, res1), PolyType(tparams2, res2)) => // @assume tp1.isHigherKinded && tp2.isHigherKinded (as they were both normalized to PolyType)
         tparams1.length == tparams2.length && {
-          if(tparams1.isEmpty) res1 <:< res2 // fast-path: monomorphic nullary method type
-          else if(tparams1.head.owner.isMethod) {  // fast-path: polymorphic method type -- type params cannot be captured
-            ((tparams1, tparams2).zipped forall ((p1, p2) =>
-              p2.info.substSym(tparams2, tparams1) <:< p1.info)) &&
+          if (tparams1.isEmpty) res1 <:< res2 // fast-path: monomorphic nullary method type
+          else if (tparams1.head.owner.isMethod) {  // fast-path: polymorphic method type -- type params cannot be captured
+            (tparams1 corresponds tparams2)((p1, p2) => p2.info.substSym(tparams2, tparams1) <:< p1.info) &&
             res1 <:< res2.substSym(tparams2, tparams1)
           } else { // normalized higher-kinded type
             //@M for an example of why we need to generate fresh symbols, see neg/tcpoly_ticket2101.scala
             val tpsFresh = cloneSymbols(tparams1) // @M cloneSymbols(tparams2) should be equivalent -- TODO: check
 
-            ((tparams1, tparams2).zipped forall ((p1, p2) =>
-              p2.info.substSym(tparams2, tpsFresh) <:< p1.info.substSym(tparams1, tpsFresh))) &&
-              res1.substSym(tparams1, tpsFresh) <:< res2.substSym(tparams2, tpsFresh)
+            (tparams1 corresponds tparams2)((p1, p2) =>
+              p2.info.substSym(tparams2, tpsFresh) <:< p1.info.substSym(tparams1, tpsFresh)) &&   // @PP: corresponds
+            res1.substSym(tparams1, tpsFresh) <:< res2.substSym(tparams2, tpsFresh)
 
             //@M the forall in the previous test could be optimised to the following,
             // but not worth the extra complexity since it only shaves 1s from quick.comp
@@ -4306,13 +4313,13 @@ A type's typeSymbol should never be inspected directly.
         tp1.isNotNull && tp1 <:< nn2.underlying
       case mt2: MethodType =>
         tp1 match {
-          case MethodType(params1, res1) =>
+          case mt1 @ MethodType(params1, res1) =>
             val params2 = mt2.params
             val res2 = mt2.resultType
             (params1.length == params2.length &&
-             matchingParams(params1, params2, tp1.isInstanceOf[JavaMethodType], tp2.isInstanceOf[JavaMethodType]) &&
+             matchingParams(params1, params2, mt1.isJava, mt2.isJava) &&
              (res1 <:< res2) &&
-             tp1.isInstanceOf[ImplicitMethodType] == tp2.isInstanceOf[ImplicitMethodType])
+             mt1.isImplicit == mt2.isImplicit)
           case _ =>
             false
         }
@@ -4382,8 +4389,7 @@ A type's typeSymbol should never be inspected directly.
    *  that all elements of `tps1' conform to corresponding elements
    *  of `tps2'?
    */
-  def isSubTypes(tps1: List[Type], tps2: List[Type]): Boolean =
-    tps1.length == tps2.length && ((tps1, tps2).zipped forall (_ <:< _))
+  def isSubTypes(tps1: List[Type], tps2: List[Type]): Boolean = (tps1 corresponds tps2)(_ <:< _)
 
   /** Does type `tp' implement symbol `sym' with same or
    *  stronger type? Exact only if `sym' is a member of some
@@ -4424,13 +4430,13 @@ A type's typeSymbol should never be inspected directly.
           alwaysMatchSimple || tp1 =:= tp2
       }
     tp1 match {
-      case MethodType(params1, res1) =>
+      case mt1 @ MethodType(params1, res1) =>
         tp2 match {
-          case MethodType(params2, res2) =>
-            params1.length == params2.length && // useful pre-secreening optimization
-            matchingParams(params1, params2, tp1.isInstanceOf[JavaMethodType], tp2.isInstanceOf[JavaMethodType]) &&
+          case mt2 @ MethodType(params2, res2) =>
+            params1.length == params2.length && // useful pre-screening optimization
+            matchingParams(params1, params2, mt1.isJava, mt2.isJava) &&
             matchesType(res1, res2, alwaysMatchSimple) &&
-            tp1.isInstanceOf[ImplicitMethodType] == tp2.isInstanceOf[ImplicitMethodType]
+            mt1.isImplicit == mt2.isImplicit
           case PolyType(List(), res2) =>
             if (params1.isEmpty) matchesType(res1, res2, alwaysMatchSimple)
             else matchesType(tp1, res2, alwaysMatchSimple)
@@ -4616,7 +4622,7 @@ A type's typeSymbol should never be inspected directly.
    */
   def isWithinBounds(pre: Type, owner: Symbol, tparams: List[Symbol], targs: List[Type]): Boolean = {
     val bounds = instantiatedBounds(pre, owner, tparams, targs)
-    (bounds, targs).zipped forall (_ containsType _)
+    (bounds corresponds targs)(_ containsType _)  // @PP: corresponds
   }
 
   def instantiatedBounds(pre: Type, owner: Symbol, tparams: List[Symbol], targs: List[Type]): List[TypeBounds] =
diff --git a/src/compiler/scala/tools/nsc/symtab/classfile/ICodeReader.scala b/src/compiler/scala/tools/nsc/symtab/classfile/ICodeReader.scala
index c75c9982de..6011d68a6f 100644
--- a/src/compiler/scala/tools/nsc/symtab/classfile/ICodeReader.scala
+++ b/src/compiler/scala/tools/nsc/symtab/classfile/ICodeReader.scala
@@ -145,17 +145,15 @@ abstract class ICodeReader extends ClassfileParser {
   }
 
   /** Checks if tp1 is the same type as tp2, modulo implict methods.
-   *  We don't care about the distinction between implcit and explicit
+   *  We don't care about the distinction between implicit and explicit
    *  methods as this point, and we can't get back the information from
    *  bytecode anyway.
    */
   private def sameType(tp1: Type, tp2: Type): Boolean = (tp1, tp2) match {
-    case (MethodType(args1, resTpe1), MethodType(args2, resTpe2)) =>
-      if (tp1.isInstanceOf[ImplicitMethodType] || tp2.isInstanceOf[ImplicitMethodType]) {
-        MethodType(args1, resTpe1) =:= MethodType(args2, resTpe2)
-      } else
-        tp1 =:= tp2
-    case _ => tp1 =:= tp2
+    case (mt1 @ MethodType(args1, resTpe1), mt2 @ MethodType(args2, resTpe2)) if mt1.isImplicit || mt2.isImplicit =>
+      MethodType(args1, resTpe1) =:= MethodType(args2, resTpe2)
+    case _ =>
+      tp1 =:= tp2
   }
 
   override def parseMethod() {
diff --git a/src/compiler/scala/tools/nsc/symtab/classfile/Pickler.scala b/src/compiler/scala/tools/nsc/symtab/classfile/Pickler.scala
index e080df9210..fd4c7ab99f 100644
--- a/src/compiler/scala/tools/nsc/symtab/classfile/Pickler.scala
+++ b/src/compiler/scala/tools/nsc/symtab/classfile/Pickler.scala
@@ -586,9 +586,9 @@ abstract class Pickler extends SubComponent {
           writeRef(tp.typeSymbol); writeRefs(parents); REFINEDtpe
         case ClassInfoType(parents, decls, clazz) =>
           writeRef(clazz); writeRefs(parents); CLASSINFOtpe
-        case MethodType(formals, restpe) =>
+        case mt @ MethodType(formals, restpe) =>
           writeRef(restpe); writeRefs(formals)
-          if (entry.isInstanceOf[ImplicitMethodType]) IMPLICITMETHODtpe
+          if (mt.isImplicit) IMPLICITMETHODtpe
           else METHODtpe
         case PolyType(tparams, restpe) =>
           writeRef(restpe); writeRefs(tparams); POLYtpe
@@ -1037,8 +1037,8 @@ abstract class Pickler extends SubComponent {
           print("REFINEDtpe "); printRef(tp.typeSymbol); printRefs(parents);
         case ClassInfoType(parents, decls, clazz) =>
           print("CLASSINFOtpe "); printRef(clazz); printRefs(parents);
-        case MethodType(formals, restpe) =>
-          print(if (entry.isInstanceOf[ImplicitMethodType]) "IMPLICITMETHODtpe " else "METHODtpe ");
+        case mt @ MethodType(formals, restpe) =>
+          print(if (mt.isImplicit) "IMPLICITMETHODtpe " else "METHODtpe ");
           printRef(restpe); printRefs(formals)
         case PolyType(tparams, restpe) =>
           print("POLYtpe "); printRef(restpe); printRefs(tparams);
diff --git a/src/compiler/scala/tools/nsc/transform/LazyVals.scala b/src/compiler/scala/tools/nsc/transform/LazyVals.scala
index 03339163a1..23dda60f87 100644
--- a/src/compiler/scala/tools/nsc/transform/LazyVals.scala
+++ b/src/compiler/scala/tools/nsc/transform/LazyVals.scala
@@ -95,13 +95,11 @@ abstract class LazyVals extends Transform with ast.TreeDSL {
 
       val bmps = bitmaps(methSym) map (ValDef(_, ZERO))
 
-      // Martin to Iulian: Don't we need to compare lengths here?
-      def isMatch(params: List[Ident]) = (params.tail, methSym.tpe.params).zipped forall (_.tpe == _.tpe)
+      def isMatch(params: List[Ident]) = (params.tail corresponds methSym.tpe.params)(_.tpe == _.tpe) // @PP: corresponds
 
       if (bmps.isEmpty) rhs else rhs match {
         case Block(assign, l @ LabelDef(name, params, rhs1))
           if name.toString == ("_" + methSym.name) && isMatch(params) =>
-            val sym = l.symbol
             Block(assign, treeCopy.LabelDef(l, name, params, typed(prependStats(bmps, rhs1))))
 
         case _ => prependStats(bmps, rhs)
diff --git a/src/compiler/scala/tools/nsc/typechecker/EtaExpansion.scala b/src/compiler/scala/tools/nsc/typechecker/EtaExpansion.scala
index 586c21a31d..ee267690f1 100644
--- a/src/compiler/scala/tools/nsc/typechecker/EtaExpansion.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/EtaExpansion.scala
@@ -26,7 +26,7 @@ trait EtaExpansion { self: Analyzer =>
     }
 
     def unapply(tree: Tree): Option[(List[ValDef], Tree, List[Tree])] = tree match {
-      case Function(vparams, Apply(fn, args)) if (vparams, args).zipped forall isMatch =>
+      case Function(vparams, Apply(fn, args)) if (vparams corresponds args)(isMatch) => // @PP: corresponds
         Some((vparams, fn, args))
       case _ =>
         None
diff --git a/src/compiler/scala/tools/nsc/typechecker/Implicits.scala b/src/compiler/scala/tools/nsc/typechecker/Implicits.scala
index c8e2afad3d..eb04ab984b 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Implicits.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Implicits.scala
@@ -387,9 +387,9 @@ self: Analyzer =>
         result
       }
 
-      def matchesPtView(tp: Type, ptarg: Type, ptres: Type, undet: List[Symbol]): Boolean =  tp match {
-        case MethodType(params, restpe) =>
-          if (tp.isInstanceOf[ImplicitMethodType]) matchesPtView(restpe, ptarg, ptres, undet)
+      def matchesPtView(tp: Type, ptarg: Type, ptres: Type, undet: List[Symbol]): Boolean = tp match {
+        case mt @ MethodType(params, restpe) =>
+          if (mt.isImplicit) matchesPtView(restpe, ptarg, ptres, undet)
           else params.length == 1 && matchesArgRes(params.head.tpe, restpe, ptarg, ptres, undet)
         case ExistentialType(tparams, qtpe) =>
           matchesPtView(normalize(tp), ptarg, ptres, undet)
diff --git a/src/compiler/scala/tools/nsc/typechecker/Infer.scala b/src/compiler/scala/tools/nsc/typechecker/Infer.scala
index 4d1b3c83fe..bde84827b2 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Infer.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Infer.scala
@@ -175,8 +175,10 @@ trait Infer {
     tvars map instantiate
   }
 
-  def skipImplicit(tp: Type) =
-    if (tp.isInstanceOf[ImplicitMethodType]) tp.resultType else tp
+  def skipImplicit(tp: Type) = tp match {
+    case mt: MethodType if mt.isImplicit  => mt.resultType
+    case _                                => tp
+  }
 
   /** Automatically perform the following conversions on expression types:
    *  A method type becomes the corresponding function type.
@@ -185,8 +187,8 @@ trait Infer {
    *  This method seems to be performance critical.
    */
   def normalize(tp: Type): Type = tp match {
-    case MethodType(params, restpe) if (!restpe.isDependent) =>
-      if (tp.isInstanceOf[ImplicitMethodType]) normalize(restpe)
+    case mt @ MethodType(params, restpe) if (!restpe.isDependent) =>
+      if (mt.isImplicit) normalize(restpe)
       else functionType(params map (_.tpe), normalize(restpe))
     case PolyType(List(), restpe) => // nullary method type
       normalize(restpe)
@@ -401,8 +403,8 @@ trait Infer {
         isPlausiblyCompatible(mt.resultType, pt)
       case ExistentialType(tparams, qtpe) =>
         isPlausiblyCompatible(qtpe, pt)
-      case MethodType(params, restpe) =>
-        if (tp.isInstanceOf[ImplicitMethodType]) isPlausiblyCompatible(restpe, pt)
+      case mt @ MethodType(params, restpe) =>
+        if (mt.isImplicit) isPlausiblyCompatible(restpe, pt)
         else pt match {
           case TypeRef(pre, sym, args) =>
             if (sym.isAliasType) {
@@ -457,8 +459,8 @@ trait Infer {
     }
 
     final def normSubType(tp: Type, pt: Type): Boolean = tp match {
-      case MethodType(params, restpe) =>
-        if (tp.isInstanceOf[ImplicitMethodType]) normSubType(restpe, pt)
+      case mt @ MethodType(params, restpe) =>
+        if (mt.isImplicit) normSubType(restpe, pt)
         else  pt match {
           case TypeRef(pre, sym, args) =>
             if (sym.isAliasType) {
@@ -517,8 +519,8 @@ trait Infer {
 
     def isCoercible(tp: Type, pt: Type): Boolean = false
 
-    def isCompatibleArgs(tps: List[Type], pts: List[Type]): Boolean =
-      (tps, pts).zipped forall isCompatibleArg
+    def isCompatibleArgs(tps: List[Type], pts: List[Type]) =
+      (tps corresponds pts)(isCompatibleArg)  // @PP: corresponds
 
     /* -- Type instantiation------------------------------------------------ */
 
diff --git a/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala b/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala
index 7b41c7b249..fcc5a3cbf4 100644
--- a/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala
@@ -903,7 +903,7 @@ abstract class RefChecks extends InfoTransform {
           val clazz = pat.tpe.typeSymbol;
           clazz == seltpe.typeSymbol &&
           clazz.isClass && (clazz hasFlag CASE) &&
-          ((args, clazz.primaryConstructor.tpe.asSeenFrom(seltpe, clazz).paramTypes).zipped forall isIrrefutable)
+          (args corresponds clazz.primaryConstructor.tpe.asSeenFrom(seltpe, clazz).paramTypes)(isIrrefutable) // @PP: corresponds
         case Typed(pat, tpt) =>
           seltpe <:< tpt.tpe
         case Ident(nme.WILDCARD) =>