*** empty log message ***

Author: odersky

bin/test-nsc

@@ -2,19 +2,19 @@
 alias scala      java -Xms16m -ea -classpath /home/linuxsoft/apps/java-1.4.2_08/jre/lib/rt.jar:$HOME/scala/objects/main/lib/scala:$HOME/scala/objects/main/lib/tools:/tmp/classes
 alias scala-debug scala -Djava.compiler=NONE
 alias nsc        "scala scala.tools.nsc.Main -classpath "/tmp/newclasses:$HOME/scala/sources:$HOME/scala/newsources" -d /tmp/newclasses"
-nsc -verbose -prompt -nopredefs Predef.scala runtime/ScalaRunTime.scala -skip:tailcalls -skip:transmatch -check:term
-nsc -verbose -prompt *.scala -skip:tailcalls -skip:transmatch -check:term
-nsc -verbose -prompt collection/*.scala -skip:tailcalls -skip:transmatch -check:term
-nsc -verbose -prompt collection/mutable/*.scala -skip:tailcalls -skip:transmatch -check:term
-nsc -verbose -prompt collection/immutable/*.scala -skip:tailcalls -skip:transmatch -check:term
-nsc -verbose -prompt concurrent/*.scala -skip:tailcalls -skip:transmatch -check:term
-nsc -verbose -prompt io/*.scala -skip:tailcalls -skip:transmatch -check:term
-nsc -verbose -prompt mobile/*.scala -skip:tailcalls -skip:transmatch -check:term
-nsc -verbose -prompt runtime/*.scala runtime/*/*.scala -skip:tailcalls -skip:transmatch -check:term
-nsc -verbose -prompt text/*.scala -skip:tailcalls -skip:transmatch -check:term
-nsc -verbose -prompt testing/*.scala -skip:tailcalls -skip:transmatch -check:term
-nsc -verbose -prompt util/*/*.scala -skip:tailcalls -skip:transmatch -check:term
-nsc -verbose -prompt xml*.scala xml/*/*.scala -skip:tailcalls -skip:transmatch -check:term
+nsc -verbose -prompt -nopredefs Predef.scala runtime/ScalaRunTime.scala -check:term $*
+nsc -verbose -prompt *.scala -check:term $*
+nsc -verbose -prompt collection/*.scala -check:term $*
+nsc -verbose -prompt collection/mutable/*.scala -check:term $*
+nsc -verbose -prompt collection/immutable/*.scala -check:term $*
+nsc -verbose -prompt concurrent/*.scala -check:term $*
+nsc -verbose -prompt io/*.scala -check:term $*
+nsc -verbose -prompt mobile/*.scala -check:term $*
+nsc -verbose -prompt runtime/*.scala runtime/*/*.scala -check:term $*
+nsc -verbose -prompt text/*.scala -check:term $*
+nsc -verbose -prompt testing/*.scala -check:term $*
+nsc -verbose -prompt util/*/*.scala -check:term $*
+nsc -verbose -prompt xml*.scala xml/*/*.scala -check:term $*
 rm -r /tmp/newclasses/scala/tools/nsc
-nsc -verbose -prompt tools/nsc/*.scala -skip:tailcalls -skip:transmatch -check:term
+nsc -verbose -prompt tools/nsc/*.scala tools/nsc/matching/*.scala -check:term $*
 

newsources/scala/Array.scala

@@ -10,7 +10,8 @@
 
 package scala;
 
-final class Array[A](val length: Int) extends Cloneable with java.io.Serializable with Seq[A] {
+final class Array[A](_length: Int) extends Cloneable with java.io.Serializable with Seq[A] {
+  def length: Int = throw new Error();
   def apply(i: Int): A = throw new Error();
   def update(i: Int, x: A): Unit = throw new Error();
   def elements: Iterator[A] = throw new Error();

sources/scala/Enumeration.scala

@@ -114,7 +114,7 @@ abstract class Enumeration(initial: Int, names: String*) {
 
     trait Value extends Ordered[Value] {
         def id: Int;
-        def compareTo[S >: Value <% Ordered[S]](that: S): Int = that match {
+        override def compareTo[S >: Value <% Ordered[S]](that: S): Int = that match {
           case that1: Value => id - that1.id
           case _            => -(that compareTo this)
         }

sources/scala/tools/nsc/Global.scala

@@ -12,7 +12,7 @@ import scala.collection.mutable.{HashSet,HashMap}
 
 import symtab._;
 import symtab.classfile.{PickleBuffer, Pickler};
-import util._;
+import util.ListBuffer;
 import ast._;
 import ast.parser._;
 import typechecker._;
@@ -132,6 +132,13 @@ class Global(val settings: Settings, val reporter: Reporter) extends SymbolTable
 
 // Phases ------------------------------------------------------------
 
+  var globalPhase: Phase = NoPhase;
+
+  override def phase_=(p: Phase): unit = {
+    assert(p.id <= globalPhase.id + 1);
+    super.phase_=(p)
+  }
+
   abstract class GlobalPhase(prev: Phase) extends Phase(prev) {
     def run: unit = units foreach applyPhase;
     def apply(unit: CompilationUnit): unit;
@@ -170,6 +177,11 @@ class Global(val settings: Settings, val reporter: Reporter) extends SymbolTable
   object transMatcher extends TransMatcher {
     val global: Global.this.type = Global.this;
   }
+
+  object explicitOuter extends ExplicitOuter {
+    val global: Global.this.type = Global.this;
+  }
+
   object erasure extends Erasure {
     val global: Global.this.type = Global.this;
   }
@@ -194,8 +206,10 @@ class Global(val settings: Settings, val reporter: Reporter) extends SymbolTable
     uncurry,
     tailCalls,
     transMatcher,
+    explicitOuter,
     erasure,
-    sampleTransform);
+    if (settings.Xshowicode.value) genicode
+    else sampleTransform);
 
   val parserPhase = syntaxAnalyzer.newPhase(NoPhase);
   val firstPhase = parserPhase;
@@ -212,17 +226,20 @@ class Global(val settings: Settings, val reporter: Reporter) extends SymbolTable
     }
   }
 
-  // temporary: icode is turned on explicitely
-  if (settings.Xshowicode.value)
-    p = genicode.newPhase(p);
-
   val terminalPhase = new GlobalPhase(p) {
     def name = "terminal";
     def apply(unit: CompilationUnit): unit = {}
   }
 
-  val namerPhase = parserPhase.next;
-  val typerPhase = namerPhase.next;
+  def phaseNamed(name: String): Phase = {
+    var p: Phase = firstPhase;
+    while (p.next != p && p.name != name) p = p.next;
+    if (p.name != name) NoPhase else p
+  }
+
+  val namerPhase = phaseNamed("namer");
+  val typerPhase = phaseNamed("typer");
+  val erasurePhase = phaseNamed("erasure");
 
   val typer = new analyzer.Typer(analyzer.NoContext.make(EmptyTree, definitions.RootClass, new Scope())) {
     override def typed(tree: Tree, mode: int, pt: Type): Tree = {
@@ -252,8 +269,6 @@ class Global(val settings: Settings, val reporter: Reporter) extends SymbolTable
   /** A map from compiled top-level symbols to their picklers */
   val symData = new HashMap[Symbol, PickleBuffer];
 
-  var globalPhase: Phase = NoPhase;
-
   def compileSources(sources: List[SourceFile]): unit = {
     val startTime = System.currentTimeMillis();
     unitbuf.clear;

sources/scala/tools/nsc/Main.scala

@@ -59,7 +59,8 @@ object Main {
 	else
 	  compiler.compile(command.files);
       } catch {
-	case ex @ FatalError(msg) =>
+	case ex: FatalError => // todo: replace with ex @ FatalError(msg)
+          val msg = ex.msg;
 	  if (command.settings.debug.value)
 	    ex.printStackTrace();
 	  reporter.error(null, "fatal error: " + msg);

sources/scala/tools/nsc/Phase.scala

@@ -5,9 +5,16 @@
 // $Id$
 package scala.tools.nsc;
 
+import symtab.Flags;
+
 abstract class Phase(val prev: Phase) {
   val id: int = if (prev == null) 0 else prev.id + 1;
 
+  def newFlags: long = 0l;
+  private var fmask: long =
+    if (prev == null) Flags.InitialFlags else prev.flagMask | newFlags;
+  def flagMask: long = fmask;
+
   private var nx: Phase = this;
   if (prev != null) prev.nx = this;
 
@@ -16,7 +23,6 @@ abstract class Phase(val prev: Phase) {
   def name: String;
   def description: String = name;
   def erasedTypes: boolean = false;
-
   def run: unit;
 
   override def toString() = name;

sources/scala/tools/nsc/SubComponent.scala

@@ -8,10 +8,22 @@ package scala.tools.nsc;
 /** An nsc sub-component.
  */
 abstract class SubComponent {
+
+  /** The global environment; overridden by instantiation in Global. */
   val global: Global;
+
+  /** The name of the phase */
   val phaseName: String;
+
+  /** New flags defined by the phase which are not valid before */
+  def phaseNewFlags: long = 0;
+
+  /** The phase factory */
   def newPhase(prev: Phase): Phase;
+
+  /** A standard phase template */
   abstract class StdPhase(prev: Phase) extends global.GlobalPhase(prev) {
     def name = phaseName;
+    override def newFlags = phaseNewFlags;
   }
 }

sources/scala/tools/nsc/ast/TreeGen.scala

@@ -33,9 +33,15 @@ abstract class TreeGen {
       }
     case TypeRef(pre, sym, args) =>
       assert(phase.erasedTypes);
-      (if (sym.isModuleClass && !sym.isRoot)
-	Select(mkQualifier(sym.owner.tpe), sym.sourceModule)
-       else This(sym)) setType sym.tpe
+      if (sym.isModuleClass && !sym.isRoot) {
+        val qual = Select(mkQualifier(sym.owner.tpe), sym.sourceModule);
+        qual.tpe match {
+	  case MethodType(List(), restpe) =>
+	    Apply(qual, List()) setType restpe
+          case _ =>
+            qual
+        }
+      } else This(sym)
   }
 
   /** Builds a reference to given symbol with given stable prefix. */
@@ -65,19 +71,19 @@ abstract class TreeGen {
   def mkStableRef(sym: Symbol): Tree  = stabilize(mkRef(sym));
 
   def This(sym: Symbol): Tree =
-    global.This(sym.name) setSymbol sym setType atPhase(phase.next)(sym.thisType);
+    global.This(sym.name) setSymbol sym setType sym.thisType;
 
   def Ident(sym: Symbol) = {
     assert(sym.isTerm);
     sym.setFlag(ACCESSED);
-    global.Ident(sym.name) setSymbol sym setType atPhase(phase.next)(sym.tpe);
+    global.Ident(sym.name) setSymbol sym setType sym.tpe;
   }
 
   def Select(qual: Tree, sym: Symbol) = {
     assert(sym.isTerm);
     sym.setFlag(ACCESSED);
     val result = global.Select(qual, sym.name) setSymbol sym;
-    if (qual.tpe != null) result setType atPhase(phase.next)(qual.tpe.memberType(sym));
+    if (qual.tpe != null) result setType qual.tpe.memberType(sym);
     result
   }
 
@@ -89,7 +95,6 @@ abstract class TreeGen {
         definitions.Any_isInstanceOfErased
       else
         definitions.Any_isInstanceOf;
-
     Apply(
       TypeApply(
         Select(value, sym),

sources/scala/tools/nsc/ast/TreeInfo.scala

@@ -34,6 +34,21 @@ abstract class TreeInfo {
     case _ => false
   }
 
+  /** Is tree legal as a member definition of an interface?
+   */
+  def isInterfaceMember(tree: Tree): boolean = tree match {
+    case EmptyTree                     => true
+    case Import(_, _)                  => true
+    case AbsTypeDef(_, _, _, _)        => true
+    case AliasTypeDef(_, _, _, _)      => true
+    case DefDef(mods, _, _, _, _, __)  => (mods & DEFERRED) != 0
+    case ValDef(mods, _, _, _)         => (mods & DEFERRED) != 0
+    case DocDef(_, definition)         => isInterfaceMember(definition)
+    case Attributed(_, definition)     => isInterfaceMember(definition)
+    case _ => false
+  }
+
+
   /** Is tree a pure definition?
    */
   def isPureDef(tree: Tree): boolean = tree match {
@@ -43,12 +58,14 @@ abstract class TreeInfo {
        | AbsTypeDef(_, _, _, _)
        | AliasTypeDef(_, _, _, _)
        | Import(_, _)
-       | DefDef(_, nme.CONSTRUCTOR, _, _, _, _) =>
+       | DefDef(_, _, _, _, _, _) =>
       true
     case ValDef(mods, _, _, rhs) =>
       (mods & MUTABLE) == 0 && isPureExpr(rhs)
     case DocDef(_, definition) =>
       isPureDef(definition)
+    case Attributed(_, definition) =>
+      isPureDef(definition)
     case _ =>
       false
   }

sources/scala/tools/nsc/ast/TreePrinters.scala

@@ -79,7 +79,14 @@ abstract class TreePrinters {
     def printOpt(prefix: String, tree: Tree): unit =
       if (!tree.isEmpty) { print(prefix); print(tree) }
 
-    def printModifiers(flags: int): unit = {
+    def printFlags(tree: Tree, flags: long): unit =
+      printModifiers(
+	if (tree.symbol == NoSymbol) flags
+	else if (settings.debug.value) tree.symbol.flags
+	else tree.symbol.flags & SourceFlags.asInstanceOf[long]);
+	  //todo: check codegen so that we can remove this
+
+    def printModifiers(flags: long): unit = {
       val mask = if (settings.debug.value) -1 else PrintableFlags;
       val s = flagsToString(flags & mask);
       if (s.length() != 0) print(s + " ")
@@ -94,19 +101,19 @@ abstract class TreePrinters {
           print("<empty>");
 
         case ClassDef(mods, name, tparams, tp, impl) =>
-          printModifiers(mods); print("class " + symName(tree, name));
+          printFlags(tree, mods); print("class " + symName(tree, name));
           printTypeParams(tparams);
           printOpt(": ", tp); print(" extends "); print(impl);
 
         case PackageDef(packaged, stats) =>
           print("package "); print(packaged); printColumn(stats, " {", ";", "}")
 
         case ModuleDef(mods, name, impl) =>
-          printModifiers(mods); print("object " + symName(tree, name));
+          printFlags(tree, mods); print("object " + symName(tree, name));
           print(" extends "); print(impl);
 
         case ValDef(mods, name, tp, rhs) =>
-          printModifiers(mods);
+          printFlags(tree, mods);
           print(if ((mods & MUTABLE) != 0) "var " else "val ");
           print(symName(tree, name));
           printOpt(": ", tp);
@@ -116,16 +123,16 @@ abstract class TreePrinters {
           }
 
         case DefDef(mods, name, tparams, vparamss, tp, rhs) =>
-          printModifiers(mods);
+          printFlags(tree, mods);
           print("def " + symName(tree, name));
           printTypeParams(tparams); vparamss foreach printValueParams;
           printOpt(": ", tp); printOpt(" = ", rhs);
 
         case AbsTypeDef(mods, name, lo, hi) =>
-          printModifiers(mods); print("type "); printParam(tree);
+          printFlags(tree, mods); print("type "); printParam(tree);
 
         case AliasTypeDef(mods, name, tparams, rhs) =>
-          printModifiers(mods); print("type " + symName(tree, name));
+          printFlags(tree, mods); print("type " + symName(tree, name));
           printTypeParams(tparams); printOpt(" = ", rhs);
 
         case LabelDef(name, params, rhs) =>
@@ -265,7 +272,7 @@ abstract class TreePrinters {
             case ClassDef(_, _, _, _, impl) => ClassDef(tree.symbol, impl)
             case ModuleDef(_, _, impl)      => ModuleDef(tree.symbol, impl)
             case ValDef(_, _, _, rhs)       => ValDef(tree.symbol, rhs)
-            case DefDef(_, _, _, _, _, rhs) => DefDef(tree.symbol, vparamss => rhs)
+            case DefDef(_, _, _, vparamss, _, rhs) => DefDef(tree.symbol, vparamss => rhs)
             case AbsTypeDef(_, _, _, _)     => AbsTypeDef(tree.symbol)
             case AliasTypeDef(_, _, _, rhs) => AliasTypeDef(tree.symbol, rhs)
             case _ => tree