*** empty log message ***

Author: odersky

sources/scala/tools/nsc/Global.scala

@@ -96,7 +96,6 @@ abstract class TreeGen {
     result
   }
 
-
   /** Builds an instance test with given value and type. */
   def mkIsInstanceOf(value: Tree, tpe: Type, erased: Boolean): Tree = {
     val sym =

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

@@ -56,7 +56,8 @@ object Flags {
 
   final val IS_ERROR      = 0x100000000l; // symbol is an error symbol
   final val OVERLOADED    = 0x200000000l; // symbol is overloaded
-  final val FLATTENED     = 0x400000000l; // class has been lifted out to package level
+  final val LIFTED        = 0x400000000l; // class has been lifted out to package level
+					  // local value has been lifted out to class level
   final val MIXEDIN       = 0x800000000l; // member has been mixed in
 
   final val EXPANDEDNAME  = 0x1000000000l; // name has been expanded with class suffix
@@ -79,7 +80,11 @@ object Flags {
   final val lateFINAL    = (FINAL: long) << LateShift;
   final val notPRIVATE   = (PRIVATE: long) << AntiShift;
   final val notPROTECTED = (PROTECTED: long) << AntiShift;
-  final val notFINAL     = (FINAL: long) << AntiShift;
+  final val notABSTRACT  = (ABSTRACT: long) << AntiShift;
+  final val notOVERRIDE  = (OVERRIDE: long) << AntiShift;
+
+  final val STATICMODULE = lateMODULE;
+  final val STATICMEMBER = notOVERRIDE;
 
   // masks
   /** This flags can be set when class or module symbol is first created. */
@@ -115,11 +120,14 @@ object Flags {
     else if (flag == INTERFACE) "<interface>"
     else if (flag == IS_ERROR) "<is-error>"
     else if (flag == OVERLOADED) "<overloaded>"
+    else if (flag == LIFTED) "<lifted>"
     else if (flag == TRANS_FLAG) "<trans-flag>"
     else if (flag == MIXEDIN) "<mixedin>"
     else if (flag == EXPANDEDNAME) "<expandedname>"
     else if (flag == INITIALIZED) "<initialized>"
     else if (flag == LOCKED) "<locked>"
+    else if (flag == STATICMODULE) "<staticobject>"
+    else if (flag == STATICMEMBER) "<staticmember>"
     else flag.asInstanceOf[int] match {
       case IMPLICIT      => "implicit"
       case FINAL         => "final"

sources/scala/tools/nsc/symtab/Flags.scala

@@ -203,6 +203,8 @@ class Names {
      */
     final def lastPos(c: char): int = lastPos(c, len - 1);
 
+    final def lastPos(s: String): int = lastPos(s, len - s.length());
+
     /** return the index of last occurrence of char c in this name from `start',
      *  -1 if not found
      */
@@ -212,6 +214,22 @@ class Names {
       i
     }
 
+    /** return the index of last occurrence of string s in this name from `start',
+     *  -1 if not found
+     */
+    final def lastPos(s: String, start: int): int = {
+      var i = lastPos(s.charAt(0), start);
+      while (i >= 0) {
+        var j = 1;
+        while (s.charAt(j) == chrs(index + i + j)) {
+          j = j + 1;
+          if (j == s.length()) return i;
+        }
+        i = lastPos(s.charAt(0), i - 1)
+      }
+      -s.length()
+    }
+
     /** does this name start with prefix?
      */
     final def startsWith(prefix: Name): boolean = startsWith(prefix, 0);

sources/scala/tools/nsc/symtab/Names.scala

@@ -62,56 +62,72 @@ abstract class StdNames: SymbolTable {
     val HASHkw = newTermName("#");
     val ATkw = newTermName("@");
 
-    private val LOCAL_PREFIX_STRING = "local$";
-    private val MIXIN_PREFIX_STRING = "mixin$";
-    private val SUPER_PREFIX_STRING = "super$";
-    private val ACCESS_PREFIX_STRING = "access$";
-    private val TUPLE_FIELD_PREFIX_STRING = "_";
-    private val TYPE_PREFIX_STRING = "type$";
-
-    val LOCAL_PREFIX = newTermName(LOCAL_PREFIX_STRING);
-
-    def LOCAL(clazz: Symbol) = newTermName(LOCAL_PREFIX_STRING + clazz.name);
+    val LOCALDUMMY_PREFIX_STRING = "local$";
+    val SUPER_PREFIX_STRING = "super$";
+    val EXPAND_SEPARATOR_STRING = "$$";
+    val TUPLE_FIELD_PREFIX_STRING = "_";
 
+    def LOCAL(clazz: Symbol) = newTermName(LOCALDUMMY_PREFIX_STRING + clazz.name);
     def TUPLE_FIELD(index: int) = newTermName(TUPLE_FIELD_PREFIX_STRING + index);
 
-    def isLocalName(name: Name) = originalName(name).endsWith(LOCAL_SUFFIX);
-    def isSetterName(name: Name) = originalName(name).endsWith(_EQ);
+    val LOCAL_SUFFIX = newTermName(" ");
+    val SETTER_SUFFIX = encode("_=");
+    val IMPL_CLASS_SUFFIX = newTermName("$class");
+    val MODULE_SUFFIX = newTermName("$module");
+    val LOCALDUMMY_PREFIX = newTermName(LOCALDUMMY_PREFIX_STRING);
 
-    def originalName(name: Name) = name.subName(0, name.pos("$$"));
+    def isLocalName(name: Name) = name.endsWith(LOCAL_SUFFIX);
+    def isSetterName(name: Name) = name.endsWith(SETTER_SUFFIX);
+    def isLocalDummyName(name: Name) = name.startsWith(LOCALDUMMY_PREFIX);
 
-    private def applyToOriginal(name: Name, f: Name => Name): Name = {
-      val oname = originalName(name);
-      if (oname == name) f(name)
-      else newTermName(f(oname).toString() + name.subName(oname.length, name.length))
+//    def originalName(name: Name): Name = {
+    def originalName(name: Name): Name = {
+      var i = name.length;
+      while (i >= 2 && !(name(i - 1) == '$' && name(i - 2) == '$')) i = i - 1;
+      if (i >= 2) {
+        while (i >= 3 && name(i - 3) == '$') i = i - 1;
+        name.subName(i, name.length)
+      } else name
     }
+//    val result = originalName(name);
+//    System.out.println("oroginal " + name + " = " + result);
+//    result
+//    }
 
     def localToGetter(name: Name): Name = {
       assert(isLocalName(name));//debug
-      applyToOriginal(name, oname => oname.subName(0, oname.length - LOCAL_SUFFIX.length));
+      name.subName(0, name.length - LOCAL_SUFFIX.length);
     }
 
     def getterToLocal(name: Name): Name = {
       assert(!isLocalName(name) && !isSetterName(name));//debug
-      applyToOriginal(name, oname => newTermName(oname.toString() + LOCAL_SUFFIX));
+      newTermName(name.toString() + LOCAL_SUFFIX);
     }
 
     def getterToSetter(name: Name): Name = {
       assert(!isLocalName(name) && !isSetterName(name));//debug
-      applyToOriginal(name, oname => newTermName(oname.toString() + SETTER_SUFFIX));
+      newTermName(name.toString() + SETTER_SUFFIX);
     }
 
     def setterToGetter(name: Name): Name = {
-      assert(isSetterName(name));//debug
-      applyToOriginal(name, oname => oname.subName(0, oname.length - SETTER_SUFFIX.length));
+      name.subName(0, name.length - SETTER_SUFFIX.length);
     }
 
     def getterName(name: Name): Name =
       if (isLocalName(name)) localToGetter(name) else name;
 
+    def isImplClassName(name: Name): boolean =
+      name endsWith IMPL_CLASS_SUFFIX;
+
     def implClassName(name: Name): Name =
       newTypeName(name.toString() + IMPL_CLASS_SUFFIX);
 
+    def moduleVarName(name: Name): Name =
+      newTermName(name.toString() + MODULE_SUFFIX);
+
+    def isModuleVarName(name: Name): boolean =
+      name.endsWith(MODULE_SUFFIX); //todo handle also local modules
+
     def superName(name: Name) = newTermName("super$" + name);
 
     val ERROR = newTermName("<error>");
@@ -133,14 +149,13 @@ abstract class StdNames: SymbolTable {
     val ROOT = newTermName("<root>");
     val REPEATED_PARAM_CLASS_NAME = newTermName("<repeated>");
     val BYNAME_PARAM_CLASS_NAME = newTermName("<byname>");
-    val SELF = newTermName("$self");
+    val SELF = newTermName("$this");
 
     val CONSTRUCTOR = newTermName("<init>");
     val MIXIN_CONSTRUCTOR = newTermName("$init$");
     val INITIALIZER = newTermName("<init>");
     val INLINED_INITIALIZER = newTermName("$init$");
 
-    val _EQ = encode("_=");
     val MINUS = encode("-");
     val PLUS = encode("+");
     val TILDE = encode("~");
@@ -291,10 +306,6 @@ abstract class StdNames: SymbolTable {
     val JacoMetaATTR = newTermName("JacoMeta");
     val ScalaSignatureATTR = newTermName("ScalaSignature");
     val JavaInterfaceATTR = newTermName("JacoInterface");
-
-    val LOCAL_SUFFIX = newTermName(" ");
-    val SETTER_SUFFIX = _EQ;
-    val IMPL_CLASS_SUFFIX = newTermName("$class");
   }
 
   def encode(str: String): Name = newTermName(NameTransformer.encode(str));

sources/scala/tools/nsc/symtab/StdNames.scala

@@ -97,10 +97,12 @@ abstract class Symbols: SymbolTable {
     def isClass = false;       //to be overridden
 
     final def isValue = isTerm && !(isModule && hasFlag(PACKAGE | JAVA));
-    final def isVariable = isTerm && hasFlag(MUTABLE);
+    final def isVariable = isTerm && hasFlag(MUTABLE) && !isMethod;
+    final def isSetter = isTerm && hasFlag(ACCESSOR) && nme.isSetterName(name);
+       //todo: make independent of name, as this can be forged.
     final def hasGetter = isTerm && nme.isLocalName(name);
     final def isValueParameter = isTerm && hasFlag(PARAM);
-    final def isLocalDummy = isTerm && (name startsWith nme.LOCAL_PREFIX);
+    final def isLocalDummy = isTerm && nme.isLocalDummyName(name);
     final def isMethod = isTerm && hasFlag(METHOD);
     final def isSourceMethod = isTerm && (flags & (METHOD | STABLE)) == METHOD;
     final def isLabel = isTerm && hasFlag(LABEL);
@@ -115,7 +117,8 @@ abstract class Symbols: SymbolTable {
     final def isAliasType = isType && !isClass && !hasFlag(DEFERRED);
     final def isAbstractType = isType && !isClass && hasFlag(DEFERRED);
     final def isTypeParameter = isType && hasFlag(PARAM);
-    final def isAnonymousClass = isClass && (name startsWith nme.ANON_CLASS_NAME); // startsWith necessary because name may grow when lifted and also because of anonymous function classes
+    final def isAnonymousClass = isClass && (originalName startsWith nme.ANON_CLASS_NAME);
+      // startsWith necessary because name may grow when lifted and also because of anonymous function classes
     final def isRefinementClass = isClass && name == nme.REFINE_CLASS_NAME.toTypeName; // no lifting for refinement classes
     final def isModuleClass = isClass && hasFlag(MODULE);
     final def isPackageClass = isClass && hasFlag(PACKAGE);
@@ -133,8 +136,13 @@ abstract class Symbols: SymbolTable {
       isConstructor && owner.primaryConstructor == this;
 
     /** Is this symbol an implementation class for a trait ? */
-    final def isImplClass: boolean =
-      name.endsWith(nme.IMPL_CLASS_SUFFIX);
+    final def isImplClass: boolean = isClass && nme.isImplClassName(name);
+
+    final def needsImplClass: boolean =
+      isTrait && (!hasFlag(INTERFACE) || hasFlag(lateINTERFACE)) && !isImplClass;
+
+    /** Is this symbol a module variable ? */
+    final def isModuleVar: boolean = isVariable && nme.isModuleVarName(name);
 
     /** Is this symbol static (i.e. with no outer instance)? */
     final def isStatic: boolean = hasFlag(STATIC) || isRoot || owner.isStaticOwner;
@@ -203,6 +211,8 @@ abstract class Symbols: SymbolTable {
     def name: Name = rawname;
     final def name_=(name: Name): unit = { rawname = name }
 
+    def originalName = nme.originalName(name);
+
     final def flags = {
       val fs = rawflags & phase.flagMask;
       (fs | ((fs & LateFlags) >>> LateShift)) & ~(fs >>> AntiShift)
@@ -296,7 +306,7 @@ abstract class Symbols: SymbolTable {
           phase = current;
           limit = current;
 	}
-	assert(infos != null/*, name.toString() + " " + limit + " " + phase*/);
+	assert(infos != null, name);
 	infos.info
       } else {
 	var infos = this.infos;
@@ -454,11 +464,11 @@ abstract class Symbols: SymbolTable {
      */
     final def accessed: Symbol = {
       assert(hasFlag(ACCESSOR));
-      //todo: make independent of name, as this can be forged.
-      owner.info.decl(
-        nme.getterToLocal(if (nme.isSetterName(name)) nme.setterToGetter(name) else name))
+      owner.info.decl(nme.getterToLocal(if (isSetter) nme.setterToGetter(name) else name))
     }
 
+    final def implClass: Symbol = owner.info.decl(nme.implClassName(name));
+
     /** For a paramaccessor: a superclass paramaccessor for which this symbol is
      *  an alias, NoSymbol for all others */
     def alias: Symbol = NoSymbol;
@@ -492,6 +502,13 @@ abstract class Symbols: SymbolTable {
         owner.info.decl(name.toTermName).suchThat(sym => sym.rawInfo != NoType)
       else NoSymbol;
 
+    final def toInterface: Symbol =
+      if (isImplClass) {
+	val iface = tpe.parents.last.symbol;
+	assert(nme.implClassName(iface.name) == name, this);
+	iface
+      } else this;
+
     /** The module corresponding to this module class (note that this
      *  is not updated when a module is cloned).
      */
@@ -525,17 +542,13 @@ abstract class Symbols: SymbolTable {
       sym
     }
 
-    /** The superaccessor for this symbol in the definition of `base'. */
-    final def superAccessor(base: Symbol): Symbol =
-      base.info.decl(nme.superName(name)) suchThat (.alias.==(this));
-
     /** The getter of this value definition in class `base', or NoSymbol if none exists */
     final def getter(base: Symbol): Symbol =
-      base.info.decl(nme.localToGetter(name)) filter (.hasFlag(ACCESSOR));
+      base.info.decl(nme.getterName(name)) filter (.hasFlag(ACCESSOR));
 
     /** The setter of this value definition, or NoSymbol if none exists */
     final def setter(base: Symbol): Symbol =
-      base.info.decl(nme.getterToSetter(nme.localToGetter(name))) filter (.hasFlag(ACCESSOR));
+      base.info.decl(nme.getterToSetter(nme.getterName(name))) filter (.hasFlag(ACCESSOR));
 
     /** Remove private modifier from symbol `sym's definition. If `sym' is a
      *  term symbol rename it by expanding its name to avoid name clashes
@@ -559,9 +572,12 @@ abstract class Symbols: SymbolTable {
           getter(owner).expandName(base);
           setter(owner).expandName(base);
         }
-        name = newTermName(name.toString() + "$$" + base.fullNameString('$'))
+        name = base.expandedName(name)
       }
 
+    def expandedName(name: Name): Name =
+      newTermName(fullNameString('$') + nme.EXPAND_SEPARATOR_STRING + name);
+
 /*
     def referenced: Symbol =
       throw new Error("referenced inapplicable for " + this);
@@ -709,9 +725,10 @@ abstract class Symbols: SymbolTable {
     }
 
     override def alias: Symbol =
-      if (hasFlag(SUPERACCESSOR | PARAMACCESSOR)) referenced else NoSymbol;
+      if (hasFlag(SUPERACCESSOR | PARAMACCESSOR | MIXEDIN)) initialize.referenced else NoSymbol;
 
     def setAlias(alias: Symbol): TermSymbol = {
+      assert(alias != NoSymbol);
       assert(hasFlag(SUPERACCESSOR | PARAMACCESSOR | MIXEDIN));
       referenced = alias;
       this
@@ -738,12 +755,14 @@ abstract class Symbols: SymbolTable {
     override def tpe: Type = {
       assert(tpeCache != NoType, this);
       if (tpePhase != phase) {
-        if (isValid(tpePhase)) tpePhase = phase
-        else {
+        if (isValid(tpePhase)) {
+	  tpePhase = phase
+        } else {
           if (hasFlag(INITIALIZED)) tpePhase = phase;
           tpeCache = NoType;
-          tpeCache = typeRef(if (isTypeParameter) NoPrefix else owner.thisType,
-                             this, unsafeTypeParams map (.tpe))
+	  val targs = if (phase.erasedTypes && this != ArrayClass) List()
+		      else unsafeTypeParams map (.tpe);
+          tpeCache = typeRef(if (isTypeParameter) NoPrefix else owner.thisType, this, targs)
         }
       }
       assert(tpeCache != null/*, "" + this + " " + phase*/);//debug
@@ -803,12 +822,11 @@ abstract class Symbols: SymbolTable {
       val p = thisTypePhase;
       if (p != phase) {
         thisTypePhase = phase;
-        if (!isValid(p)) {
+        if (!(isValid(p) /*||
+	      thisTypePhase != null && thisTypePhase.erasedTypes && phase.erasedTypes*/)) {
 	  thisTypeCache =
-	    if (isModuleClass && !isRoot && !phase.erasedTypes) {
-              assert(sourceModule != NoSymbol, this);
-              singleType(owner.thisType, sourceModule);
-            }
+	    if (isModuleClass && !isRoot && !phase.erasedTypes)
+	      singleType(owner.thisType, sourceModule);
 	    else ThisType(this);
         }
       }