- Added factory methods for abstract types and ...

- Added factory methods for abstract types and type aliases in Symbol
- Moved AbsTypeSymbol.define and AliasTypeSymbol.define into Analyzer

9 files changed, 91 insertions, 82 deletions

diff --git a/sources/scala/tools/scalac/typechecker/Analyzer.scala b/sources/scala/tools/scalac/typechecker/Analyzer.scala
index ebaf4d5bcc..87bfd755a9 100644
--- a/sources/scala/tools/scalac/typechecker/Analyzer.scala
+++ b/sources/scala/tools/scalac/typechecker/Analyzer.scala
@@ -719,15 +719,30 @@ class Analyzer(global: scalac_Global, descr: AnalyzerPhase) extends Transformer(
   }
 
   def classSymbol(pos: int, name: Name, owner: Symbol, flags: int, scope: Scope): Symbol = {
+    val symbol = findTypeSymbol(scope, pos, CLASS, name, flags);
+    if (symbol.isNone()) owner.newClass(pos, flags, name) else symbol
+  }
+
+  def typeAliasSymbol(pos: int, name: Name, owner: Symbol, flags: int, scope: Scope): Symbol = {
+    val symbol = findTypeSymbol(scope, pos, ALIAS, name, flags);
+    if (symbol.isNone()) owner.newTypeAlias(pos, flags, name) else symbol
+  }
+
+  def absTypeSymbol(pos: int, name: Name, owner: Symbol, flags: int, scope: Scope): Symbol = {
+    val symbol = findTypeSymbol(scope, pos, TYPE, name, flags);
+    if (symbol.isNone()) owner.newAbstractType(pos, flags, name) else symbol
+  }
+
+  def findTypeSymbol(scope: Scope, pos: int, kind: int, name: Name, flags: int): Symbol = {
     val entry = scope.lookupEntry(name);
-    val clazz = entry.sym;
-    if (entry.owner == scope && clazz.isExternal() && clazz.isClassType()) {
-      updateFlags(clazz, flags);
-      clazz.pos = pos;
-      clazz.allConstructors().pos = pos;
-      clazz
+    val symbol = entry.sym;
+    if (entry.owner == scope && symbol.isExternal() && symbol.kind == kind) {
+      updateFlags(symbol, flags);
+      symbol.pos = pos;
+      symbol.allConstructors().pos = pos;
+      symbol
     } else {
-      owner.newClass(pos, flags, name)
+      Symbol.NONE;
     }
   }
 
@@ -928,7 +943,7 @@ class Analyzer(global: scalac_Global, descr: AnalyzerPhase) extends Transformer(
 	enterSym(tree, sym);
 
       case Tree$AliasTypeDef(mods, name, _, _) =>
-	val tsym: Symbol = AliasTypeSymbol.define(tree.pos, name, owner, mods, context.scope);
+	val tsym: Symbol = typeAliasSymbol(tree.pos, name, owner, mods, context.scope);
 	if (!tsym.primaryConstructor().isInitialized())
 	  tsym.primaryConstructor().setInfo(new LazyTreeType(tree));
 	enterSym(tree, tsym)
@@ -936,7 +951,7 @@ class Analyzer(global: scalac_Global, descr: AnalyzerPhase) extends Transformer(
       case Tree$AbsTypeDef(mods, name, _, _) =>
 	enterSym(
 	  tree,
-	  AbsTypeSymbol.define(tree.pos, name, owner, mods, context.scope))
+	  absTypeSymbol(tree.pos, name, owner, mods, context.scope))
 
       case Tree$Import(expr, selectors) =>
 	enterImport(tree,
diff --git a/sources/scalac/symtab/Definitions.java b/sources/scalac/symtab/Definitions.java
index 7e6ee8af50..09d996915b 100644
--- a/sources/scalac/symtab/Definitions.java
+++ b/sources/scalac/symtab/Definitions.java
@@ -673,7 +673,7 @@ public class Definitions {
     /** Creates a new type alias */
     private Symbol newAlias(Symbol owner, Name name, int flags) {
         name = name.toTypeName();
-        Symbol alias = new AliasTypeSymbol(Position.NOPOS, name, owner, flags);
+        Symbol alias = owner.newTypeAlias(Position.NOPOS, flags, name);
         owner.members().enter(alias);
         return alias;
     }
@@ -689,8 +689,7 @@ public class Definitions {
     /** Creates a new type parameter */
     private Symbol newTParam(Symbol owner, int index, Type bound) {
         Name name = Name.fromString("T" + index).toTypeName();
-        return new AbsTypeSymbol(Position.NOPOS, name, owner, Modifiers.PARAM)
-            .setInfo(bound);
+        return owner.newTParam(Position.NOPOS, 0, name, bound);
     }
 
     /** Creates a new value parameter */
diff --git a/sources/scalac/symtab/Symbol.java b/sources/scalac/symtab/Symbol.java
index 70ceaa047b..541285f3ed 100644
--- a/sources/scalac/symtab/Symbol.java
+++ b/sources/scalac/symtab/Symbol.java
@@ -127,6 +127,45 @@ public abstract class Symbol implements Modifiers, Kinds {
         return peckage;
     }
 
+    /** Creates a new type alias owned by this symbol. */
+    public final AliasTypeSymbol newTypeAlias(int pos, int flags, Name name) {
+        return new AliasTypeSymbol(pos, name, this, flags, 0);
+    }
+
+    /** Creates a new abstract type owned by this symbol. */
+    public final AbsTypeSymbol newAbstractType(int pos, int flags, Name name) {
+        return new AbsTypeSymbol(pos, name, this, flags, 0);
+    }
+
+    /** Creates a new type parameter owned by this symbol. */
+    public final AbsTypeSymbol newTParam(int pos, int flags, Name name) {
+        assert isTerm(): Debug.show(this);
+        return newAbstractType(pos, flags | PARAM, name);
+    }
+
+    /**
+     * Creates a new type parameter owned by this symbol and
+     * initializes it with the type.
+     */
+    public final AbsTypeSymbol newTParam(int pos, int flags, Name name, Type type) {
+        AbsTypeSymbol tparam = newTParam(pos, flags, name);
+        tparam.setInfo(type);
+        return tparam;
+    }
+
+    /**
+     * Creates a new type alias owned by this symbol and initializes
+     * it with the info.
+     */
+    public final AliasTypeSymbol newTypeAlias(int pos, int flags, Name name,
+        Type info)
+    {
+        AliasTypeSymbol alias = newTypeAlias(pos, flags, name);
+        alias.setInfo(info);
+        alias.allConstructors().setInfo(Type.MethodType(EMPTY_ARRAY, info));
+        return alias;
+    }
+
     /** Creates a new class owned by this symbol. */
     public final ClassSymbol newClass(int pos, int flags, Name name) {
         return newClass(pos, flags, name, 0, NONE);
@@ -1641,59 +1680,29 @@ public abstract class TypeSymbol extends Symbol {
     protected abstract TypeSymbol cloneTypeSymbolImpl(Symbol owner, int attrs);
 }
 
-public class AliasTypeSymbol extends TypeSymbol {
+public final class AliasTypeSymbol extends TypeSymbol {
 
-    /** Constructor */
-    public AliasTypeSymbol(int pos, Name name, Symbol owner, int flags) {
-        this(pos, name, owner, flags, 0);
-    }
-    public AliasTypeSymbol(int pos, Name name, Symbol owner, int flags, int attrs) {
+    /** Initializes this instance. */
+    AliasTypeSymbol(int pos, Name name, Symbol owner, int flags, int attrs) {
         super(ALIAS, pos, name, owner, flags, attrs);
     }
 
-    public static AliasTypeSymbol define(
-        int pos, Name name, Symbol owner, int flags, Scope scope) {
-        Scope.Entry e = scope.lookupEntry(name);
-        if (e.owner == scope && e.sym.isExternal() && e.sym.kind == ALIAS) {
-            AliasTypeSymbol sym = (AliasTypeSymbol) e.sym;
-            sym.update(pos, flags);
-            return sym;
-        } else {
-            return new AliasTypeSymbol(pos, name, owner, flags);
-        }
-    }
-
     protected TypeSymbol cloneTypeSymbolImpl(Symbol owner, int attrs) {
         return new AliasTypeSymbol(pos, name, owner, flags, attrs);
     }
 
 }
 
-public class AbsTypeSymbol extends TypeSymbol {
+public final class AbsTypeSymbol extends TypeSymbol {
 
     private Type lobound = null;
 
-    /** Constructor */
-    public AbsTypeSymbol(int pos, Name name, Symbol owner, int flags) {
-        this(pos, name, owner, flags, 0);
-    }
-    public AbsTypeSymbol(int pos, Name name, Symbol owner, int flags, int attrs) {
+    /** Initializes this instance. */
+    AbsTypeSymbol(int pos, Name name, Symbol owner, int flags, int attrs) {
         super(TYPE, pos, name, owner, flags, attrs);
         allConstructors().setInfo(Type.MethodType(EMPTY_ARRAY, Type.typeRef(owner.thisType(), this, Type.EMPTY_ARRAY)));
     }
 
-    public static AbsTypeSymbol define(
-        int pos, Name name, Symbol owner, int flags, Scope scope) {
-        Scope.Entry e = scope.lookupEntry(name);
-        if (e.owner == scope && e.sym.isExternal() && e.sym.kind == TYPE) {
-            AbsTypeSymbol sym = (AbsTypeSymbol) e.sym;
-            sym.update(pos, flags);
-            return sym;
-        } else {
-            return new AbsTypeSymbol(pos, name, owner, flags);
-        }
-    }
-
     public Type loBound() {
         initialize();
         return lobound == null ? Global.instance.definitions.ALL_TYPE() : lobound;
@@ -1740,7 +1749,7 @@ public final class ClassSymbol extends TypeSymbol {
     /** Initializes this instance. */
     ClassSymbol(int pos, Name name, Symbol owner, int flags, int attrs, Symbol dual) {
         super(CLASS, pos, name, owner, flags, attrs);
-        this.rebindSym = new AliasTypeSymbol(pos, Names.ALIAS(this), owner, 0);
+        this.rebindSym = owner.newTypeAlias(pos, 0, Names.ALIAS(this));
         Type rebindType = new ClassAliasLazyType();
         this.rebindSym.setInfo(rebindType);
         this.rebindSym.primaryConstructor().setInfo(rebindType);
diff --git a/sources/scalac/symtab/Type.java b/sources/scalac/symtab/Type.java
index c7d4e38a03..02808fe755 100644
--- a/sources/scalac/symtab/Type.java
+++ b/sources/scalac/symtab/Type.java
@@ -2718,7 +2718,7 @@ public class Type implements Modifiers, Kinds, TypeTags, EntryTags {
             lubSym = new TermSymbol(syms[0].pos, syms[0].name, owner, 0);
             break;
         case TYPE: case ALIAS: case CLASS:
-            lubSym = new AbsTypeSymbol(syms[0].pos, syms[0].name, owner, 0);
+            lubSym = owner.newAbstractType(syms[0].pos, 0, syms[0].name);
             lubSym.setLoBound(glb(lbs));
             break;
         default:
diff --git a/sources/scalac/symtab/classfile/AttributeParser.java b/sources/scalac/symtab/classfile/AttributeParser.java
index 9205291748..5306201edd 100644
--- a/sources/scalac/symtab/classfile/AttributeParser.java
+++ b/sources/scalac/symtab/classfile/AttributeParser.java
@@ -124,12 +124,9 @@ public class AttributeParser implements ClassfileConstants {
                         !outer.isModule() ||
                         (outer != sym.dualClass().module()))
                     	continue;
-                	AliasTypeSymbol alias =
-						new AliasTypeSymbol(Position.NOPOS, name.toTypeName(), outer, 0);
-					alias.setInfo(parser.make.classType(inner));
-					alias.allConstructors()
-						.setInfo(new Type.MethodType(Symbol.EMPTY_ARRAY, inner.info()));
-	    			parser.statics.enterNoHide(alias);
+                    Symbol alias = outer.newTypeAlias(Position.NOPOS,
+                        0, name.toTypeName(), parser.make.classType(inner));
+                    parser.statics.enterNoHide(alias);
                 }
                 //in.skip(attrLen);
                 return;
@@ -225,12 +222,11 @@ public class AttributeParser implements ClassfileConstants {
                                         if (s != Symbol.NONE)
                                 return s;
                 }
-                s = new AbsTypeSymbol(
+                s = owner.newTParam(
                         Position.NOPOS,
+                        0,
                         Name.fromString(token).toTypeName(),
-                        owner,
-                        Modifiers.PARAM);
-                        s.setInfo(parser.make.anyType());
+                        parser.make.anyType());
                         tvars.enter(s);
                 return s;
             } else
@@ -364,12 +360,11 @@ public class AttributeParser implements ClassfileConstants {
                         if ("]".equals(token))
                             break;
                         assert token.startsWith("?");
-                        Symbol s = new AbsTypeSymbol(
+                        Symbol s = owner.newTParam(
                                         Position.NOPOS,
+                                        0,
                                         Name.fromString(token).toTypeName(),
-                                        owner,
-                                        Modifiers.PARAM);
-                                                s.setInfo(parser.make.anyType());
+                                        parser.make.anyType());
                                         locals.enter(s);
                         nextToken();
                         if (token.equals("<")) {
diff --git a/sources/scalac/symtab/classfile/CLRClassParser.java b/sources/scalac/symtab/classfile/CLRClassParser.java
index cbcf042e46..ac9d630228 100644
--- a/sources/scalac/symtab/classfile/CLRClassParser.java
+++ b/sources/scalac/symtab/classfile/CLRClassParser.java
@@ -13,7 +13,6 @@ import scalac.symtab.Symbol;
 import scalac.symtab.SymbolLoader;
 import scalac.symtab.TermSymbol;
 import scalac.symtab.ClassSymbol;
-import scalac.symtab.AliasTypeSymbol;
 import scalac.symtab.Scope;
 import scalac.symtab.Modifiers;
 import scalac.symtab.Type.*;
@@ -94,13 +93,8 @@ public class CLRClassParser extends SymbolLoader {
 	    Symbol nclazz = clazz.owner().newLoadedClass(JAVA, classname, this, null);
 	    importer.map(nclazz, ntype);
 	    // create an alias in the module of the outer class
-	    AliasTypeSymbol alias =
-		new AliasTypeSymbol(Position.NOPOS, aliasname, staticsClass,
-				    translateAttributes(ntype));
-	    //
-	    alias.setInfo(make.classType(nclazz));
-	    alias.allConstructors()
-		.setInfo(MethodType(Symbol.EMPTY_ARRAY, alias.info()));
+	    Symbol alias = staticsClass.newTypeAlias(Position.NOPOS,
+                translateAttributes(ntype), aliasname, make.classType(nclazz));
 	    statics.enterNoHide(alias);
 	}
 
diff --git a/sources/scalac/symtab/classfile/UnPickle.java b/sources/scalac/symtab/classfile/UnPickle.java
index c309ed5723..e4dfc58e8d 100644
--- a/sources/scalac/symtab/classfile/UnPickle.java
+++ b/sources/scalac/symtab/classfile/UnPickle.java
@@ -225,15 +225,15 @@ public class UnPickle implements Kinds, Modifiers, EntryTags, TypeTags {
 		    int inforef = readNat();
 		    switch (tag) {
 		    case TYPEsym:
-			entries[n] = sym = new AbsTypeSymbol(
-			    Position.NOPOS, name, owner, flags);
+			entries[n] = sym = owner.newAbstractType(
+			    Position.NOPOS, flags, name);
 			sym.setInfo(getType(inforef));
 			sym.setLoBound(readTypeRef());
 			break;
 
 		    case ALIASsym:
-			entries[n] = sym = new AliasTypeSymbol(
-			    Position.NOPOS, name, owner, flags);
+			entries[n] = sym = owner.newTypeAlias(
+			    Position.NOPOS, flags, name);
 			sym.setInfo(getType(inforef));
 			Symbol constr = readSymbolRef();
 			break;
diff --git a/sources/scalac/transformer/ErasurePhase.java b/sources/scalac/transformer/ErasurePhase.java
index 8075c0d713..5fccaf4659 100644
--- a/sources/scalac/transformer/ErasurePhase.java
+++ b/sources/scalac/transformer/ErasurePhase.java
@@ -18,7 +18,6 @@ import scalac.backend.Primitives;
 import scalac.checkers.Checker;
 import scalac.checkers.CheckSymbols;
 import scalac.checkers.CheckTypes;
-import scalac.symtab.AbsTypeSymbol;
 import scalac.symtab.Definitions;
 import scalac.symtab.Modifiers;
 import scalac.symtab.Scope;
@@ -88,8 +87,7 @@ public class ErasurePhase extends Phase {
         if (global.target == global.TARGET_INT && sym ==primitives.NEW_OARRAY){
             // !!! hack for interpreter
             Name name = Name.fromString("element").toTypeName();
-            Symbol tparam = new AbsTypeSymbol(0, name, sym, Modifiers.PARAM);
-            tparam.setType(definitions.ANY_TYPE());
+            Symbol tparam = sym.newTParam(sym.pos, 0, name, definitions.ANY_TYPE());
             return Type.PolyType(new Symbol[]{tparam}, tp);
         }
         switch (primitives.getPrimitive(sym)) {
diff --git a/sources/scalac/transformer/ExplicitOuterClassesPhase.java b/sources/scalac/transformer/ExplicitOuterClassesPhase.java
index 0b32029ef4..fe9d669b5b 100644
--- a/sources/scalac/transformer/ExplicitOuterClassesPhase.java
+++ b/sources/scalac/transformer/ExplicitOuterClassesPhase.java
@@ -20,7 +20,6 @@ import scalac.ast.GenTransformer;
 import scalac.ast.Tree;
 import scalac.ast.Tree.Ident;
 import scalac.ast.Tree.Template;
-import scalac.symtab.AbsTypeSymbol;
 import scalac.symtab.Modifiers;
 import scalac.symtab.Scope;
 import scalac.symtab.Symbol;
@@ -150,8 +149,8 @@ public class ExplicitOuterClassesPhase extends Phase {
         for (int i = 0; i < outers.length; i++) {
             if (outers[i].isStable) continue;
             Name tname = Names.OUTER(constructor, outers[i].clasz);
-            tlinks[i] = new AbsTypeSymbol(constructor.pos, tname, constructor, tflags);
-            tlinks[i].setInfo(outers[i].clasz.type());
+            tlinks[i] = constructor.newTParam(
+                constructor.pos, tflags, tname, outers[i].clasz.type());
         }
 
         // create outer value link