*** empty log message ***

9 files changed, 238 insertions, 107 deletions

diff --git a/sources/scala/tools/scalac/ast/parser/Parser.scala b/sources/scala/tools/scalac/ast/parser/Parser.scala
index 0466e11b3d..279b0e7fe4 100644
--- a/sources/scala/tools/scalac/ast/parser/Parser.scala
+++ b/sources/scala/tools/scalac/ast/parser/Parser.scala
@@ -248,18 +248,17 @@ class Parser(unit: Unit) {
 
     def makeForCont(pos: int, pat: Tree, body: Tree): Tree = {
       pat match {
-        case Tree$Ident(name1) =>
-          if (name1.isVariable())
-            make.Function(
+        case Tree$Ident(name1) if (name1.isVariable()) =>
+          make.Function(
               pos,
               NewArray.ValDef(
                 make.ValDef(
                   pat.pos, Modifiers.PARAM, name1, Tree.Empty, Tree.Empty)),
               body);
 	case _ =>
+	  make.Visitor(pos, NewArray.CaseDef(
+            make.CaseDef(pos, pat, Tree.Empty, body)));
       }
-      make.Visitor(pos, NewArray.CaseDef(
-        make.CaseDef(pos, pat, Tree.Empty, body)));
     }
 
     enums(0) match {
@@ -269,7 +268,7 @@ class Parser(unit: Unit) {
 	} else {
 	  val newenums = new Array[Tree](enums.length - 1);
           enums(1) match {
-            case Tree$PatDef(mods2, pat, rhs) =>
+            case Tree$PatDef(mods2, pat2, rhs2) =>
               System.arraycopy(enums, 1, newenums, 0, newenums.length);
               makeFor1(
 		pos, flatmapName, pat, rhs,
@@ -282,8 +281,6 @@ class Parser(unit: Unit) {
               makeFor(pos, newenums, mapName, flatmapName, body);
           }
 	}
-      case _ =>
-        throw new ApplicationError();
     }
   }
 
diff --git a/sources/scala/tools/scalac/ast/parser/Scanner.scala b/sources/scala/tools/scalac/ast/parser/Scanner.scala
index 4b4c5a8869..678a39aa37 100644
--- a/sources/scala/tools/scalac/ast/parser/Scanner.scala
+++ b/sources/scala/tools/scalac/ast/parser/Scanner.scala
@@ -250,6 +250,7 @@ class Scanner(_unit: Unit) extends TokenData {
 		     'p' | 'q' | 'r' | 's' | 't' |
 		     'u' | 'v' | 'w' | 'x' | 'y' |
 		     'z' =>
+		  index = bp;
 		  putch(ch);
 		  nextch();
 		  if (ch != '\'') {
diff --git a/sources/scala/tools/scalac/typechecker/Analyzer.scala b/sources/scala/tools/scalac/typechecker/Analyzer.scala
index 2b906e0db4..b7b8f74f43 100644
--- a/sources/scala/tools/scalac/typechecker/Analyzer.scala
+++ b/sources/scala/tools/scalac/typechecker/Analyzer.scala
@@ -49,23 +49,27 @@ class Analyzer(global: Global, descr: AnalyzerPhase) extends Transformer(global)
   private var patternVars: HashMap = _;   // for pattern matching; maps x to {true,false}
 
   override def apply(units: Array[Unit]): unit = {
-    for (val i <- Iterator.range(0, units.length))
+    var i = 0; while (i <  units.length) {
       enterUnit(units(i));
+      i = i + 1
+    }
     super.apply(units);
     var n = descr.newSources.size();
     while (n > 0) { // this calls apply(u) for every unit `u'.
       val l = global.units.length;
       val newUnits = new Array[Unit](l + n);
       System.arraycopy(
-	global.units.asInstanceOf[Array[Object]], 0,
-	newUnits.asInstanceOf[Array[Object]], 0, l);
-      for (val i <- Iterator.range(0, n)) {
+	global.units.asInstanceOf[Array[Object]], 0, newUnits.asInstanceOf[Array[Object]], 0, l);
+      var i = 0; while (i < n) {
         newUnits(i + l) = descr.newSources.get(i).asInstanceOf[Unit];
+	i = i + 1
       }
       global.units = newUnits;
       descr.newSources.clear();
-      for (val i <- Iterator.range(l, newUnits.length))
-        apply(newUnits(i));
+      var j = l; while (j < newUnits.length) {
+        apply(newUnits(j));
+	j = j + 1
+      }
       n = descr.newSources.size();
     }
   }
@@ -118,7 +122,7 @@ class Analyzer(global: Global, descr: AnalyzerPhase) extends Transformer(global)
   }
 
   def genSymData(stats: Array[Tree]): unit = {
-    for (val i <- Iterator.range(0, stats.length)) {
+    var i = 0; while (i < stats.length) {
       stats(i) match {
 	case Tree$ClassDef(_, _, _, _, _, _) | Tree$ModuleDef(_, _, _, _) =>
 	  val sym = stats(i).symbol();
@@ -134,6 +138,7 @@ class Analyzer(global: Global, descr: AnalyzerPhase) extends Transformer(global)
 	  genSymData(templ.body);
 	case _ =>
       }
+      i = i + 1
     }
   }
 
@@ -218,9 +223,10 @@ class Analyzer(global: Global, descr: AnalyzerPhase) extends Transformer(global)
       symtype match {
 	case Type$OverloadedType(alts, alttypes) =>
 	  var nacc: int = 0;
-	  for (val i <- Iterator.range(0, alts.length)) {
+	  var i = 0; while (i < alts.length) {
 	    if (isAccessible(alts(i), site))
 	      nacc = nacc + 1;
+	    i = i + 1
 	  }
 	  if (nacc == 0) {
 	    error(pos, "" + sym + " cannot be accessed in " + site.getType().widen());
@@ -229,12 +235,13 @@ class Analyzer(global: Global, descr: AnalyzerPhase) extends Transformer(global)
 	    val alts1: Array[Symbol] = new Array[Symbol](nacc);
 	    val alttypes1: Array[Type] = new Array[Type](nacc);
 	    nacc = 0;
-	    for (val i <- Iterator.range(0, alts.length)) {
+	    var i = 0; while (i < alts.length) {
 	      if (isAccessible(alts(i), site)) {
 		alts1(nacc) = alts(i);
 		alttypes1(nacc) = alttypes(i);
 		nacc = nacc + 1;
 	      }
+	      i = i + 1
 	    }
 	    new Type$OverloadedType(alts1, alttypes1)
 	  }
@@ -278,9 +285,10 @@ class Analyzer(global: Global, descr: AnalyzerPhase) extends Transformer(global)
     accessWithin(sym.owner())
     ||
     ((sym.flags & PRIVATE) == 0) &&
-    site.getType().symbol().isSubClass(sym.owner()) &&
+    site.getType().symbol().isSubClass(
+      if (sym.isConstructor()) sym.constructorClass() else sym.owner()) &&
     (site.isInstanceOf[Tree$Super] ||
-    isSubClassOfEnclosing(site.getType().symbol()))
+     isSubClassOfEnclosing(site.getType().symbol()))
   }
 
 // Checking methods ----------------------------------------------------------
@@ -375,9 +383,10 @@ class Analyzer(global: Global, descr: AnalyzerPhase) extends Transformer(global)
 	      selfType + " does not conform to " + parents(i) +
 	      "'s selftype " + parents(i).instanceType());
       }
-      for (val j <- Iterator.range(0, i)) {
+      var j = 0; while (j < i) {
 	if (parents(i).symbol() == parents(j).symbol())
 	  error(constrs(i).pos, "" + parents(i).symbol() + " is inherited twice");
+	j = j + 1
       }
       i = i + 1;
     }
@@ -411,11 +420,12 @@ class Analyzer(global: Global, descr: AnalyzerPhase) extends Transformer(global)
   */
   def checkEtaExpandable(pos: int, tp: Type): unit = tp match {
     case Type$MethodType(params, restype) =>
-      for (val i <- Iterator.range(0, params.length)) {
+      var i = 0; while (i < params.length) {
 	if ((params(i).flags & DEF) != 0)
 	  error(pos, "method with `def' parameters needs to be fully applied");
 	if ((params(i).flags & REPEATED) != 0)
 	  error(pos, "method with `*' parameters needs to be fully applied");
+	i = i + 1
       }
       checkEtaExpandable(pos, restype);
     case _ =>
@@ -454,8 +464,9 @@ class Analyzer(global: Global, descr: AnalyzerPhase) extends Transformer(global)
       }
 
     case Type$CompoundType(parents, members) =>
-      for (val i <- Iterator.range(0, parents.length)) {
+      var i = 0; while (i < parents.length) {
 	checkNonCyclic(pos, parents(i));
+	i = i + 1
       }
 
     case Type$SingleType(pre, sym) =>
@@ -507,9 +518,13 @@ class Analyzer(global: Global, descr: AnalyzerPhase) extends Transformer(global)
   /** Check that there are no dependent parameter types among parameters
   */
   def checkNoEscapeParams(vparams: Array[Array[Tree$ValDef]]): unit = {
-    for (val i <- Iterator.range(0, vparams.length))
-      for (val j <- Iterator.range(0, vparams(i).length))
+    var i = 0; while (i < vparams.length) {
+      var j = 0; while (j < vparams(i).length) {
 	checkNoEscape(vparams(i)(j).pos, vparams(i)(j).tpe.getType());
+	j = j + 1
+      }
+      i = i + 1
+    }
   }
 
   /** Check that tree represents a pure definition.
@@ -856,12 +871,14 @@ class Analyzer(global: Global, descr: AnalyzerPhase) extends Transformer(global)
   /** Enter all symbols in statement list
   */
   def enterSyms(stats: Array[Tree]): unit = {
-    for (val i <- Iterator.range(0, stats.length))
+    var i = 0; while (i < stats.length) {
       enterSym(stats(i));
+      i = i + 1
+    }
   }
 
   def enterParams[t <: Tree](params: Array[t]): Array[Symbol] = {
-    for (val i <- Iterator.range(0, params.length)) {
+    var i = 0; while (i < params.length) {
       enterSym(params(i));
       (params(i) : Tree) match {
 	case Tree$ValDef(mods, _, _, _) =>
@@ -870,14 +887,16 @@ class Analyzer(global: Global, descr: AnalyzerPhase) extends Transformer(global)
 		  "`*' parameter must be the only parameter of a `('...`)' section");
 	case _ =>
       }
+      i = i + 1
     }
     Tree.symbolOf(params.asInstanceOf[Array[Tree]])
   }
 
   def enterParams(vparams: Array[Array[Tree$ValDef]]): Array[Array[Symbol]] = {
     val vparamSyms = new Array[Array[Symbol]](vparams.length);
-    for (val i <- Iterator.range(0, vparams.length)) {
+    var i = 0; while (i < vparams.length) {
       vparamSyms(i) = enterParams(vparams(i));
+      i = i + 1
     }
     vparamSyms
   }
@@ -885,12 +904,13 @@ class Analyzer(global: Global, descr: AnalyzerPhase) extends Transformer(global)
   /** Re-enter type parameters in current scope.
   */
   def reenterParams(tparams: Array[Tree$AbsTypeDef], tsyms: Array[Symbol]): unit = {
-    for (val i <- Iterator.range(0, tparams.length)) {
+    var i = 0; while (i < tparams.length) {
       tsyms(i).pos = tparams(i).pos;
       tsyms(i).name = tparams(i).name;
       //necessary since tsyms might have been unpickled
       tparams(i).setSymbol(tsyms(i));
       context.scope.enter(tsyms(i));
+      i = i + 1
     }
   }
 
@@ -904,20 +924,22 @@ class Analyzer(global: Global, descr: AnalyzerPhase) extends Transformer(global)
 	rest = restp;
       case _ =>
     }
-    for (val j <- Iterator.range(0, vparamss.length)) {
+    var j = 0; while (j < vparamss.length) {
       val vparams = vparamss(j);
       rest match {
 	case Type$MethodType(vsyms, restp) =>
-	  for (val i <- Iterator.range(0, vparams.length)) {
+	  var i = 0; while (i < vparams.length) {
 	    vsyms(i).pos = vparams(i).pos;
 	    vsyms(i).name = vparams(i).name;
             //necessary since vsyms might have been unpickled
 	    vparams(i).setSymbol(vsyms(i));
 	    context.scope.enter(vsyms(i));
+	    i = i + 1
 	  }
 	  rest = restp;
 	case _ =>
       }
+      j = j + 1
     }
   }
 
@@ -1072,11 +1094,12 @@ class Analyzer(global: Global, descr: AnalyzerPhase) extends Transformer(global)
 	  checkStable(expr);
 	  owntype = expr.getType();
 	  val tp: Type = owntype.widen();
-	  for (val i <- Iterator.range(0, selectors.length)) {
+	  var i = 0; while (i < selectors.length) {
 	    if (selectors(i) != Names.IMPORT_WILDCARD &&
 		tp.lookup(selectors(i)) == Symbol.NONE &&
 		tp.lookup(selectors(i).toTypeName()) == Symbol.NONE)
-	      error(tree.pos, "" + NameTransformer.decode(selectors(i)) + " is not a member of " + expr + " of type " + expr.getType());
+	      error(tree.pos, "" + NameTransformer.decode(selectors(i)) + " is not a member of " + expr);
+	    i = i + 2
 	  }
 
 	case _ =>
@@ -1548,8 +1571,10 @@ class Analyzer(global: Global, descr: AnalyzerPhase) extends Transformer(global)
     tree match {
       case Tree$Visitor(cases) =>
 	val cases1 = cases;
-	for (val i <- Iterator.range(0, cases.length))
+	var i = 0; while (i < cases.length) {
 	  cases1(i) = transformCase(cases(i), pattpe, pt);
+	  i = i + 1
+	}
 	return copy.Visitor(tree, cases1)
 	  .setType(Type.lub(Tree.typeOf(cases1.asInstanceOf[Array[Tree]])));
       case _ =>
@@ -1576,7 +1601,7 @@ class Analyzer(global: Global, descr: AnalyzerPhase) extends Transformer(global)
 
   def transformStatSeq(stats: Array[Tree], exprOwner: Symbol): Array[Tree] = {
     var stats1 = stats;
-    for (val i <- Iterator.range(0, stats.length)) {
+    var i = 0; while (i < stats.length) {
       val stat: Tree = stats(i);
       if (context.owner.isCompoundSym() && !TreeInfo.isDeclaration(stat)) {
 	error(stat.pos, "only declarations allowed here");
@@ -1598,6 +1623,7 @@ class Analyzer(global: Global, descr: AnalyzerPhase) extends Transformer(global)
 			 stats1.asInstanceOf[Array[Object]], 0, i);
       }
       stats1(i) = stat1;
+      i = i + 1
     }
     stats1
   }
@@ -1605,7 +1631,7 @@ class Analyzer(global: Global, descr: AnalyzerPhase) extends Transformer(global)
   /** Attribute a sequence of constructor invocations.
   */
   def transformConstrInvocations(pos: int, constrs: Array[Tree]): Array[Tree] = {
-    for (val i <- Iterator.range(0, constrs.length)) {
+    var i = 0; while (i < constrs.length) {
       constrs(i) = transform(constrs(i), CONSTRmode | SUPERmode, Type.AnyType);
       val f: Symbol = TreeInfo.methSymbol(constrs(i));
       if (f != null) {
@@ -1618,12 +1644,13 @@ class Analyzer(global: Global, descr: AnalyzerPhase) extends Transformer(global)
 	  }
 	}
       }
+      i = i + 1
     }
     constrs
   }
 
   def transformConstrInvocationArgs(constrs: Array[Tree]): unit = {
-    for (val i <- Iterator.range(0, constrs.length)) {
+    var i = 0; while (i < constrs.length) {
       constrs(i) match {
 	case Tree$Apply(fn, args) =>
 	  if (fn.getType().isInstanceOf[Type$MethodType])
@@ -1632,6 +1659,7 @@ class Analyzer(global: Global, descr: AnalyzerPhase) extends Transformer(global)
 	      fn.getType(), EXPRmode, args, Type.AnyType);
 	case _ =>
       }
+      i = i + 1
     }
   }
 
@@ -1652,12 +1680,15 @@ class Analyzer(global: Global, descr: AnalyzerPhase) extends Transformer(global)
     val body1 = transformStatSeq(templ.body, templ.symbol());
     popContext();
     if (owner.isTrait()) {
-      for (val i <- Iterator.range(0, parents.length)) {
+      var i = 0; while (i < parents.length) {
 	checkPureConstr(parents(i), owner);
 	if (i >= 1) checkTrait(parents(i), owner);
+	i = i + 1
+      }
+      var j = 0; while (j < templ.body.length) {
+	checkPureDef(body1(j), owner);
+	j = j + 1
       }
-      for (val i <- Iterator.range(0, templ.body.length))
-	checkPureDef(body1(i), owner);
     }
     val templ1: Tree$Template = copy.Template(templ, parents, body1);
     templ1.setType(owner.getType());
@@ -1687,9 +1718,10 @@ class Analyzer(global: Global, descr: AnalyzerPhase) extends Transformer(global)
 	  return null;
 	}
 	if (tparams.length == 0) {
-	  for (val i <- Iterator.range(0, args.length)) {
+	  var i = 0; while (i < args.length) {
 	    args(i) = transform(args(i), argMode, formals(i));
 	    argtypes(i) = args(i).getType().deconst();
+	    i = i + 1
 	  }
 	} else {
 	  // targs: the type arguments inferred from the prototype
@@ -1697,22 +1729,28 @@ class Analyzer(global: Global, descr: AnalyzerPhase) extends Transformer(global)
 
 	  // argpts: prototypes for arguments
 	  val argpts = new Array[Type](formals.length);
-	  for (val i <- Iterator.range(0, formals.length))
+	  var i = 0; while (i < formals.length) {
 	    argpts(i) = formals(i).subst(tparams, targs);
+	    i = i + 1
+	  }
 
  	  // transform arguments with (targs/tparams)formals as prototypes
-	  for (val i <- Iterator.range(0, args.length))
+	  { var i = 0; while (i < args.length) {
 	    args(i) = transform(
 	      args(i), argMode | POLYmode, formals(i).subst(tparams, targs));
+	    i = i + 1
+	  }}
 
 	  // targs1: same as targs except that every AnyType is mapped to
 	  // formal parameter type.
 	  val targs1 = new Array[Type](targs.length);
-	  for (val i <- Iterator.range(0, targs.length))
+	  { var i = 0; while (i < targs.length) {
 	    targs1(i) = if (targs(i) != Type.AnyType) targs(i)
 			else tparams(i).getType();
+	    i = i + 1
+	  }}
 
-	  for (val i <- Iterator.range(0, args.length)) {
+	  { var i = 0; while (i < args.length) {
 	    argtypes(i) = args(i).getType().deconst();
 	    argtypes(i) match {
 	      case Type$PolyType(tparams1, restype1) =>
@@ -1722,13 +1760,14 @@ class Analyzer(global: Global, descr: AnalyzerPhase) extends Transformer(global)
 		  argpts(i));
 	      case _ =>
 	    }
-	  }
+	    i = i + 1
+	  }}
 	}
 	//   desugarizing ident patterns
 	if (params.length == 1 && (params(0).flags & REPEATED) != 0) {
 	  if ((mode & PATTERNmode) != 0) {
 	    def desug_allIdentPatterns(trees: Array[Tree], currentOwner: Symbol): unit = {
-	      for (val i <- Iterator.range(0, trees.length))
+	      var i = 0; while (i < trees.length) {
 		trees(i) match {
 		  case Tree$Ident(name) =>
 		    if (name != Names.PATTERN_WILDCARD) {
@@ -1740,6 +1779,8 @@ class Analyzer(global: Global, descr: AnalyzerPhase) extends Transformer(global)
                     }
 		  case _ =>
 		}
+		i = i + 1
+	      }
 	    }
     	    desug_allIdentPatterns(args, context.owner);
 	  } else {
@@ -1762,16 +1803,18 @@ class Analyzer(global: Global, descr: AnalyzerPhase) extends Transformer(global)
 	transformArgs(pos, meth, tparams2, restp, argMode, args, pt)
 
       case Type.ErrorType =>
-	for (val i <- Iterator.range(0, args.length)) {
+	var i = 0; while (i < args.length) {
 	  args(i) = transform(args(i), argMode, Type.ErrorType);
 	  argtypes(i) = args(i).getType().deconst();
+	  i = i + 1
 	}
 	argtypes
 
       case _ =>
-	for (val i <- Iterator.range(0, args.length)) {
+	var i = 0; while (i < args.length) {
 	  args(i) = transform(args(i), argMode, Type.AnyType);
 	  argtypes(i) = args(i).getType().deconst();
+	  i = i + 1
 	}
 	argtypes
     }
@@ -1820,8 +1863,10 @@ class Analyzer(global: Global, descr: AnalyzerPhase) extends Transformer(global)
   }
 
   def transform(trees: Array[Tree], mode: int): Array[Tree] = {
-    for (val i <- Iterator.range(0, trees.length))
+    var i = 0; while (i < trees.length) {
       trees(i) = transform(trees(i), mode);
+      i = i + 1
+    }
     trees
   }
 
@@ -2001,12 +2046,16 @@ class Analyzer(global: Global, descr: AnalyzerPhase) extends Transformer(global)
 	    if ((curmode & CONSTRmode) != 0) {
 	      stats1(0) = transform(stats1(0), curmode, pt);
 	      context.enclClass.owner.flags = context.enclClass.owner.flags & ~INCONSTRUCTOR;
-	      for (val i <- Iterator.range(1, stats1.length))
+	      var i = 1; while (i < stats1.length) {
 		stats1(i) = transform(stats1(i), EXPRmode);
+		i = i + 1
+	      }
 	      stats1(0).getType()
 	    } else {
-	      for (val i <- Iterator.range(0, stats1.length - 1))
+	      var i = 0; while (i < stats1.length - 1) {
 		stats1(i) = transform(stats1(i), EXPRmode);
+		i = i + 1
+	      }
 	      if (stats1.length > 0) {
 		stats1(stats1.length - 1) =
 		  transform(stats1(stats1.length - 1), curmode & ~FUNmode, pt);
@@ -2020,10 +2069,11 @@ class Analyzer(global: Global, descr: AnalyzerPhase) extends Transformer(global)
 	    .setType(owntype);
 
         case Tree$Sequence(trees) =>
-          for (val i <- Iterator.range(0, trees.length)) {
+          var i = 0; while (i < trees.length) {
 	    trees(i) = transform(trees(i),
 				 this.mode | SEQUENCEmode,
 				 pt);
+	    i = i + 1
           }
           copy.Sequence(tree, trees).setType(pt);
 
@@ -2032,8 +2082,10 @@ class Analyzer(global: Global, descr: AnalyzerPhase) extends Transformer(global)
 	  this.inAlternative = true;
 
 	  val newts = new Array[Tree](choices.length);
-	  for (val i <- Iterator.range(0, choices.length))
+	  var i = 0; while (i < choices.length) {
 	    newts(i) = transform(choices(i), this.mode, pt);
+	    i = i + 1
+	  }
 
 	  //val tpe: Type = Type.lub(Tree.typeOf(newts));
 
@@ -2388,6 +2440,7 @@ class Analyzer(global: Global, descr: AnalyzerPhase) extends Transformer(global)
 	      var matching1: int = -1;
 	      var matching2: int = -1;
 	      for (val i <- Iterator.range(0, alttypes.length)) {
+		// can't replace with while because of backend crash???
 		val alttp: Type = alttypes(i) match {
 		  case Type$PolyType(_, restp) => restp;
 		  case t => t
@@ -2481,8 +2534,9 @@ class Analyzer(global: Global, descr: AnalyzerPhase) extends Transformer(global)
 		fn1.getType() match {
 		  case Type$MethodType(params, restp1) =>
 		    val formals = infer.formalTypes(params, args.length);
-		    for (val i <- Iterator.range(0, args.length)) {
+		    var i = 0; while (i < args.length) {
 		      args(i) = adapt(args(i), argMode, formals(i));
+		      i = i + 1
 		    }
 		    return constfold.tryToFold(
 		      copy.Apply(tree, fn1, args)
@@ -2620,9 +2674,10 @@ class Analyzer(global: Global, descr: AnalyzerPhase) extends Transformer(global)
 	  val self: Type = Type.compoundType(ptypes, members);
 	  val clazz: Symbol = self.symbol();
 	  pushContext(tree, clazz, members);
-	  for (val i <- Iterator.range(0, refinements.length)) {
+	  var i = 0; while (i < refinements.length) {
 	    val m = enterSym(refinements(i));
 	    m.flags = m.flags | OVERRIDE;
+	    i = i + 1
 	  }
 	  val refinements1 = transformStatSeq(refinements, Symbol.NONE);
 	  popContext();
diff --git a/sources/scala/tools/scalac/typechecker/Infer.scala b/sources/scala/tools/scalac/typechecker/Infer.scala
index 1886a42822..fe29f71b89 100644
--- a/sources/scala/tools/scalac/typechecker/Infer.scala
+++ b/sources/scala/tools/scalac/typechecker/Infer.scala
@@ -69,8 +69,10 @@ class Infer(global: Global, gen: TreeGen, make: TreeFactory) {
   */
   private def variance(tparams: Array[Symbol], tp: Type): Array[int] = {
     val vs: Array[int] = new Array[int](tparams.length);
-    for (val i <- Iterator.range(0, vs.length))
+    { var i = 0; while (i < vs.length) {
       vs(i) = variance(tparams(i), tp);
+      i = i + 1;
+    }}
     vs
   }
 
@@ -78,8 +80,10 @@ class Infer(global: Global, gen: TreeGen, make: TreeFactory) {
   */
   private def variance(tparams: Array[Symbol], tps: Array[Type]): Array[int] = {
     val vs: Array[int] = new Array[int](tparams.length);
-    for (val i <- Iterator.range(0, vs.length))
+    { var i = 0; while (i < vs.length) {
       vs(i) = variance(tparams(i), tps);
+      i = i + 1;
+    }}
     vs
   }
 
@@ -87,9 +91,10 @@ class Infer(global: Global, gen: TreeGen, make: TreeFactory) {
   */
   private def variance(tparam: Symbol, syms: Array[Symbol]): int = {
     var v: int = VARIANCES;
-    for (val i <- Iterator.range(0, syms.length)) {
+    { var i = 0; while (i < syms.length) {
       v = v & variance(tparam, syms(i));
-    }
+      i = i + 1;
+    }}
     v
   }
 
@@ -112,9 +117,10 @@ class Infer(global: Global, gen: TreeGen, make: TreeFactory) {
      */
   private def variance(tparam: Symbol, tps: Array[Type]): int = {
     var v: int = VARIANCES;
-    for (val i <- Iterator.range(0, tps.length)) {
+    { var i = 0; while (i < tps.length) {
       v = v & variance(tparam, tps(i));
-    }
+      i = i + 1;
+    }}
     v
   }
 
@@ -123,7 +129,7 @@ class Infer(global: Global, gen: TreeGen, make: TreeFactory) {
   */
   private def varianceInArgs(tvar: Symbol, tps: Array[Type], tparams: Array[Symbol]): int = {
     var v: int = VARIANCES;
-    for (val i <- Iterator.range(0, tps.length)) {
+    { var i = 0; while (i < tps.length) {
       if ((tparams(i).flags & COVARIANT) != 0) {
 	v = v & variance(tvar, tps(i));
       } else if ((tparams(i).flags & CONTRAVARIANT) != 0) {
@@ -131,7 +137,8 @@ class Infer(global: Global, gen: TreeGen, make: TreeFactory) {
       } else {
 	v = v & cut(variance(tvar, tps(i)));
       }
-    }
+      i = i + 1;
+    }}
     v
   }
 
@@ -209,8 +216,10 @@ class Infer(global: Global, gen: TreeGen, make: TreeFactory) {
       if (args.length == 1) {
 	val ft: Type = args(0);
 	// params(0) has type Seq[T], we need T here
-	for (val i <- Iterator.range(0, length))
+	{ var i = 0; while (i < length) {
 	  formals(i) = ft;
+	  i = i + 1;
+	}}
 	return formals;
       }
     }
@@ -318,39 +327,42 @@ class Infer(global: Global, gen: TreeGen, make: TreeFactory) {
 	    tvars(i) = Type.NoType;
 	    val bound: Type = if (up) tparams(i).info() else tparams(i).loBound();
 	    var cyclic: boolean = false;
-	    for (val j <- Iterator.range(0, tvars.length)) {
+	    { var j = 0; while (j < tvars.length) {
 	      if (bound.contains(tparams(j)) ||
 		  up && tparams(j).loBound().isSameAs(tparams(i).getType()) ||
 		  !up && tparams(j).info().isSameAs(tparams(i).getType())) {
 		    cyclic = cyclic | tvars(j) == Type.NoType;
 		    solve(tparams, upper, variances, tvars, j);
 	      }
-	    }
+	      j = j + 1
+	    }}
 	    if (!cyclic) {
 	      if (up) {
 		if (bound.symbol() != Global.instance.definitions.ANY_CLASS)
 		  constr.hibounds = new Type$List(
 		    bound.subst(tparams, tvars), constr.hibounds);
-		for (val j <- Iterator.range(0, tvars.length)) {
+		{ var j = 0; while (j < tvars.length) {
 		  if (tparams(j).loBound().isSameAs(
 		    tparams(i).getType())) {
 		      constr.hibounds = new Type$List(
 			tparams(j).getType().subst(tparams, tvars),
 			constr.hibounds);
-		    }
-		}
+		  }
+		  j = j + 1
+		}}
 	      } else {
 		if (bound.symbol() != Global.instance.definitions.ALL_CLASS)
 		  constr.lobounds = new Type$List(
 		    bound.subst(tparams, tvars), constr.lobounds);
-		for (val j <- Iterator.range(0, tvars.length)) {
+		{ var j = 0; while (j < tvars.length) {
 		  if (tparams(j).info().isSameAs(
 		    tparams(i).getType())) {
 		      constr.lobounds = new Type$List(
 			tparams(j).getType().subst(tparams, tvars),
 			constr.lobounds);
-		    }
-		}
+		  }
+		  j = j + 1
+		}}
 	      }
 	    }
 	    if (up) maximizeVar(tvar);
@@ -367,9 +379,10 @@ class Infer(global: Global, gen: TreeGen, make: TreeFactory) {
   */
   private def freshVars(tparams: Array[Symbol]): Array[Type] = {
     val tvars: Array[Type] = new Array[Type](tparams.length);
-    for (val i <- Iterator.range(0, tvars.length)) {
+    { var i = 0; while (i < tvars.length) {
       tvars(i) = new Type$TypeVar(tparams(i).getType(), new Type$Constraint());
-    }
+      i = i + 1
+    }}
     tvars
   }
 
@@ -390,9 +403,11 @@ class Infer(global: Global, gen: TreeGen, make: TreeFactory) {
 	  case _ =>
 	}
 	val newparams: Array[Symbol] = new Array[Symbol](tparams.length);
-	for (val i <- Iterator.range(0, tparams.length))
+	{ var i = 0; while (i < tparams.length) {
 	  newparams(i) = tparams(i).cloneSymbol();
-	for (val i <- Iterator.range(0, tparams.length)) {
+	  i = i + 1
+	}}
+	{ var i = 0; while (i < tparams.length) {
 	  newparams(i).setInfo(
 	    newparams(i).info()
 	    .subst(tparams, newparams)
@@ -401,7 +416,8 @@ class Infer(global: Global, gen: TreeGen, make: TreeFactory) {
 	    newparams(i).loBound()
 	    .subst(tparams, newparams)
 	    .subst(tparams1, newparams1));
-	}
+	  i = i + 1
+	}}
 	new Type$PolyType(newparams, restp1.subst(tparams, newparams))
 
       case Type$OverloadedType(_, _) =>
@@ -439,12 +455,13 @@ class Infer(global: Global, gen: TreeGen, make: TreeFactory) {
   */
   private def normalizeArgs(targs: Array[Type], tparams: Array[Symbol]): Array[Symbol] = {
     var uninstantiated: Type$List = Type$List.EMPTY;
-    for (val i <- Iterator.range(0, targs.length)) {
+    { var i = 0; while (i < targs.length) {
       if (targs(i).symbol() == Global.instance.definitions.ALL_CLASS) {
 	targs(i) = tparams(i).getType();
 	uninstantiated = Type$List.append(uninstantiated, targs(i));
       }
-    }
+      i = i + 1
+    }}
     Type.symbol(uninstantiated.toArray());
   }
 
@@ -459,9 +476,10 @@ class Infer(global: Global, gen: TreeGen, make: TreeFactory) {
     if (isCompatible(insttype, pt)) {
       try {
 	val restype1 = normalize(restype);
-	for (val i <- Iterator.range(0, tvars.length)) {
+	{ var i = 0; while (i < tvars.length) {
 	  solve(tparams, false, variance(tparams, restype1), tvars, i);
-	}
+	  i = i + 1
+	}}
 	tvars
       } catch {
 	case ex: NoInstance => null
@@ -484,18 +502,23 @@ class Infer(global: Global, gen: TreeGen, make: TreeFactory) {
     val tvars: Array[Type] = freshVars(tparams);
     val insttype: Type = restype.subst(tparams, tvars);
     val targs: Array[Type] = new Array[Type](tvars.length);
-    for (val i <- Iterator.range(0, tvars.length))
+    { var i = 0; while (i < tvars.length) {
       targs(i) = Type.AnyType;
+      i = i + 1
+    }}
     if (isCompatible(insttype, pt)) {
       try {
-	for (val i <- Iterator.range(0, tvars.length)) {
+	{ var i = 0; while (i < tvars.length) {
 	  targs(i) = instantiateToBound(
 	    tvars(i), variance(tparams(i), params));
-	}
+	  i = i + 1
+	}}
       } catch {
 	case ex: NoInstance =>
-	  for (val i <- Iterator.range(0, tvars.length))
+	  { var i = 0; while (i < tvars.length) {
 	    targs(i) = Type.AnyType;
+	    i = i + 1
+	  }}
       }
     }
     targs
@@ -527,10 +550,11 @@ class Infer(global: Global, gen: TreeGen, make: TreeFactory) {
 			     " is incompatible with expected type " + pt);
       return null;
     }
-    for (val i <- Iterator.range(0, tvars.length)) {
+    { var i = 0; while (i < tvars.length) {
       val tvar: Type$TypeVar = tvars(i).asInstanceOf[Type$TypeVar];
       if (!isFullyDefined(tvar)) tvar.constr.inst = Type.NoType;
-    }
+      i = i + 1
+    }}
 
     // Then define remaining type variables from argument types.
     var i = 0;
@@ -553,9 +577,10 @@ class Infer(global: Global, gen: TreeGen, make: TreeFactory) {
       }
       i = i + 1;
     }
-    for (val i <- Iterator.range(0, tvars.length)) {
+    { var i = 0; while (i < tvars.length) {
       solve(tparams, false, variance(tparams, formals), tvars, i);
-    }
+      i = i + 1
+    }}
     //System.out.println(" = " + ArrayApply.toString(tvars));//DEBUG
     tvars
   }
@@ -585,8 +610,10 @@ class Infer(global: Global, gen: TreeGen, make: TreeFactory) {
     }
     if (0 < i) {
       val argtrees: Array[Tree] = new Array[Tree](i);
-      for (val j <- Iterator.range(0, i))
+      { var j = 0; while (j < i) {
 	argtrees(j) = gen.mkType(tree.pos, targs(j));
+	j = j + 1
+      }}
       tree1 = make.TypeApply(tree.pos, tree1, argtrees);
     }
     //System.out.println(Sourcefile.files[Position.file(tree1.pos)] + ": ");
@@ -711,10 +738,11 @@ class Infer(global: Global, gen: TreeGen, make: TreeFactory) {
 	val ctpe1: Type = restype1.resultType();
 	if (ctpe1.isSubType(pt)) {
 	  try {
-	    for (val i <- Iterator.range(0, tvars.length)) {
+	    { var i = 0; while (i < tvars.length) {
 	      solve(tparams, true, variance(tparams, restype.resultType()),
 		    tvars, i);
-	    }
+	      i = i + 1
+	    }}
 	    checkBounds(tparams, tvars, "inferred ");
 	    tree.setType(restype.subst(tparams, tvars));
 	    //System.out.println("inferred constructor type: " + tree.getType());//DEBUG
@@ -800,20 +828,22 @@ class Infer(global: Global, gen: TreeGen, make: TreeFactory) {
     }
     // second, do the normal case.
     var best: int = -1;
-    for (val i <- Iterator.range(0, alttypes.length)) {
+    { var i = 0; while (i < alttypes.length) {
       if (isCompatible(alttypes(i), pt) && (best < 0 || improves(alttypes(i), alttypes(best)))) {
 	best = i;
       }
-    }
+      i = i + 1
+    }}
     if (best >= 0) {
-      for (val i <- Iterator.range(0, alttypes.length)) {
+      { var i = 0; while (i < alttypes.length) {
 	if (isCompatible(alttypes(i), pt) && best != i && !improves(alttypes(best), alttypes(i))) {
 	  throw new Type$Error(
 	    overloadResolveErrorMsg(
 	      alts(best), alttypes(best), alts(i), alttypes(i)) +
 	    " expected type " + pt);
 	}
-      }
+	i = i + 1
+      }}
       tree.setSymbol(alts(best)).setType(alttypes(best));
     }
   }
@@ -834,13 +864,14 @@ class Infer(global: Global, gen: TreeGen, make: TreeFactory) {
       return;
     }
     var best: int = -1;
-    for (val i <- Iterator.range(0, alttypes.length)) {
+    { var i = 0; while (i < alttypes.length) {
       if (isApplicable(alttypes(i), argtypes, pt) &&
 	  (best < 0 || specializes(alttypes(i), alttypes(best))))
 	best = i;
-    }
+      i = i + 1
+    }}
     if (best >= 0) {
-      for (val i <- Iterator.range(0, alttypes.length)) {
+      { var i = 0; while (i < alttypes.length) {
 	if (i != best &&
 	    isApplicable(alttypes(i), argtypes, pt) &&
 	    !(specializes(alttypes(best), alttypes(i)) &&
@@ -851,7 +882,8 @@ class Infer(global: Global, gen: TreeGen, make: TreeFactory) {
 	     " argument types " +
 	     ArrayApply.toString(argtypes.asInstanceOf[Array[Object]], "(", ",", ")") +
 	     (if (pt == Type.AnyType) "" else " and expected result type " + pt));
-      }
+	i = i + 1
+      }}
       tree.setSymbol(alts(best)).setType(alttypes(best));
     } else if (pt != Type.AnyType) {
       methodAlternative(tree, alts, alttypes, argtypes, Type.AnyType);
@@ -875,13 +907,14 @@ class Infer(global: Global, gen: TreeGen, make: TreeFactory) {
       i = i + 1;
 
     if (i < alttypes.length) {
-      for (val j <- Iterator.range(i + 1, alttypes.length)) {
+      { var j = i + 1; while (j < alttypes.length) {
 	if (alts(j).isValue() &&
 	    alttypes(j).typeParams().length == nparams)
 	  throw new Type$Error(
 	    overloadResolveErrorMsg(alts(i), alttypes(i), alts(j), alttypes(j)) +
 	    " polymorphic function with " + nparams + " parameters");
-      }
+	j = j + 1
+      }}
       tree.setSymbol(alts(i)).setType(alttypes(i));
     }
   }
diff --git a/sources/scalac/symtab/Symbol.java b/sources/scalac/symtab/Symbol.java
index 3c2ec7d70c..967cd6a6ab 100644
--- a/sources/scalac/symtab/Symbol.java
+++ b/sources/scalac/symtab/Symbol.java
@@ -1157,7 +1157,7 @@ public abstract class Symbol implements Modifiers, Kinds {
         assert this.name == that.name : Debug.show(this) + " <> " + Debug.show(that);
         assert this.owner == that.owner : Debug.show(this) + " != " + Debug.show(that);
         assert this.isConstructor() == that.isConstructor();
-        int overflags = (this.flags & that.flags & (JAVA | ACCESSFLAGS)) |
+        int overflags = (this.flags & that.flags & (JAVA | ACCESSFLAGS | DEFERRED)) |
             ((this.flags | that.flags) & ACCESSOR);
         TermSymbol overloaded = (this.isConstructor())
             ? TermSymbol.newConstructor(this.constructorClass(), overflags)
@@ -1880,8 +1880,8 @@ public class ClassSymbol extends TypeSymbol {
 		} else {
 			sym = it.next();
 			while ((sym.flags & SYNTHETIC) == 0) {
-				System.out.println("skipping " + sym);
-				sym = it.next();
+			    //System.out.println("skipping " + sym);
+			    sym = it.next();
 			}
 			for (int i = 0; i < index; i++)
 				sym = it.next();
diff --git a/sources/scalac/symtab/Type.java b/sources/scalac/symtab/Type.java
index e9a220fd55..1122d61f55 100644
--- a/sources/scalac/symtab/Type.java
+++ b/sources/scalac/symtab/Type.java
@@ -880,6 +880,7 @@ public class Type implements Modifiers, Kinds, TypeTags, EntryTags {
 
             Type symtype = pre.memberType(sym).derefDef();
             Type sym1type = pre.memberType(sym1).derefDef();
+	    if (sym1.isJava()) symtype = symtype.objParamToAny();
             switch (sym1type) {
             case OverloadedType(Symbol[] alts, Type[] alttypes):
                 for (int i = 0; i < alts.length; i++) {
@@ -896,6 +897,25 @@ public class Type implements Modifiers, Kinds, TypeTags, EntryTags {
             }
         }
     }
+    //where
+    static Map objToAnyMap = new Map() {
+	public Type apply(Type t) {
+	    if (t.symbol() == Global.instance.definitions.JAVA_OBJECT_CLASS)
+		return Global.instance.definitions.ANY_TYPE();
+	    else return t;
+	}
+    };
+
+    private Type objParamToAny() {
+	switch (this) {
+	case MethodType(Symbol[] params, Type restp):
+	    Symbol[] params1 = objToAnyMap.map(params);
+	    if (params1 == params) return this;
+	    else return MethodType(params1, restp);
+	default:
+	    return this;
+	}
+    }
 
 // Set Owner ------------------------------------------------------------------
 
diff --git a/sources/scalac/typechecker/Analyzer.java b/sources/scalac/typechecker/Analyzer.java
index fcb6eaf0d6..44b4773b87 100644
--- a/sources/scalac/typechecker/Analyzer.java
+++ b/sources/scalac/typechecker/Analyzer.java
@@ -266,7 +266,9 @@ public class Analyzer extends Transformer implements Modifiers, Kinds {
 	    accessWithin(sym.owner())
 	    ||
 	    ((sym.flags & PRIVATE) == 0) &&
-	    site.type.symbol().isSubClass(sym.owner()) &&
+	    site.type.symbol().isSubClass(
+		sym.isConstructor() ? sym.constructorClass()
+		: sym.owner()) &&
 	    (site instanceof Tree.Super ||
 	     isSubClassOfEnclosing(site.type.symbol()));
     } //where
diff --git a/sources/scalac/typechecker/RefCheck.java b/sources/scalac/typechecker/RefCheck.java
index 2aee3a04c4..3c39218c72 100644
--- a/sources/scalac/typechecker/RefCheck.java
+++ b/sources/scalac/typechecker/RefCheck.java
@@ -141,6 +141,12 @@ public class RefCheck extends Transformer implements Modifiers, Kinds {
 	}
 	if (clazz.kind == CLASS && (clazz.flags & ABSTRACT) == 0) {
 	    if ((member.flags & DEFERRED) != 0) {
+		Type[] parents = clazz.parents();
+		for (int i = 0; i < parents.length; i++) {
+		    Symbol p = parents[i].symbol();
+		    if (p.isSubClass(member.owner()) &&	(p.flags & ABSTRACT) == 0)
+			return; // everything was already checked elsewhere
+		}
 		abstractClassError(
 		    clazz,
 		    member + member.locationString() + " is not defined" +
@@ -196,10 +202,19 @@ public class RefCheck extends Transformer implements Modifiers, Kinds {
      *       M must be labelled `abstract override'.
      */
     void checkOverride(int pos, Symbol clazz, Symbol member, Symbol other) {
+	//System.out.println(member + member.locationString() + " overrides " + other + other.locationString() + " in " + clazz);//DEBUG
 	if (member.owner() == clazz)
 	    pos = member.pos;
 	else if (member.owner().isSubClass(other.owner()))
 	    return; // everything was already checked elsewhere
+	else {
+	    Type[] parents = clazz.parents();
+	    for (int i = 0; i < parents.length; i++) {
+		Symbol p = parents[i].symbol();
+		if (p.isSubClass(member.owner()) && p.isSubClass(other.owner()))
+		    return; // everything was already checked elsewhere
+	    }
+	}
 
 	if ((member.flags & PRIVATE) != 0) {
 	    overrideError(pos, member, other, "has weaker access privileges; it should not be private");
@@ -531,7 +546,6 @@ public class RefCheck extends Transformer implements Modifiers, Kinds {
 		gen.mkRef(tree.pos, mvar)});
 
 	    // def m: T = { if (m$ == null[T]) m$ = new m$class; m$ }
-	    sym.updateInfo(Type.PolyType(Symbol.EMPTY_ARRAY, sym.type()));
 	    sym.flags |= STABLE;
 	    Tree ddef = gen.DefDef(sym, body);
 
diff --git a/sources/scalac/typechecker/RefCheckPhase.java b/sources/scalac/typechecker/RefCheckPhase.java
index 7749e4b357..87a4653648 100644
--- a/sources/scalac/typechecker/RefCheckPhase.java
+++ b/sources/scalac/typechecker/RefCheckPhase.java
@@ -10,6 +10,7 @@ package scalac.typechecker;
 
 import scalac.*;
 import scalac.ast.*;
+import scalac.symtab.*;
 import scalac.checkers.*;
 
 public class RefCheckPhase extends Phase {
@@ -25,6 +26,14 @@ public class RefCheckPhase extends Phase {
             new RefCheck(global).apply(units[i]);
     }
 
+    public Type transformInfo(Symbol sym, Type tp) {
+	if (sym.isModule() && !sym.isPackage() && !sym.isGlobalModule()) {
+	    return Type.PolyType(Symbol.EMPTY_ARRAY, tp);
+	}
+	else
+	    return tp;
+    }
+
     public Checker[] postCheckers(Global global) {
         return new Checker[] {
             new CheckSymbols(global),