*** empty log message ***

2 files changed, 79 insertions, 44 deletions

diff --git a/sources/scalac/typechecker/Analyzer.java b/sources/scalac/typechecker/Analyzer.java
index 05657ba759..8d05fbc465 100644
--- a/sources/scalac/typechecker/Analyzer.java
+++ b/sources/scalac/typechecker/Analyzer.java
@@ -477,10 +477,9 @@ public class Analyzer extends Transformer implements Modifiers, Kinds {
     //where
 	private Type.Map checkNoEscapeMap = new Type.Map() {
 	    public Type apply(Type t) {
-		switch (t) {
+		switch (t.unalias()) {
 		case TypeRef(Type pre, Symbol sym, Type[] args):
-		    if (sym.kind == ALIAS) return apply(t.unalias());
-		    else if (pre instanceof Type.ThisType) checkNoEscape(t, sym);
+		    if (pre instanceof Type.ThisType) checkNoEscape(t, sym);
 		    break;
 		case SingleType(ThisType(_), Symbol sym):
 		    checkNoEscape(t, sym);
@@ -762,9 +761,10 @@ public class Analyzer extends Transformer implements Modifiers, Kinds {
 	    return enterSym(tree, sym);
 
 	case AliasTypeDef(int mods, Name name, _, _):
-	    return enterSym(
-		tree,
-		AliasTypeSymbol.define(tree.pos, name, owner, mods, context.scope));
+	    Symbol tsym = AliasTypeSymbol.define(tree.pos, name, owner, mods, context.scope);
+	    if (!tsym.primaryConstructor().isInitialized())
+		tsym.primaryConstructor().setInfo(new LazyTreeType(tree));
+	    return enterSym(tree, tsym);
 
 	case AbsTypeDef(int mods, Name name, _, _):
 	    return enterSym(
@@ -997,6 +997,8 @@ public class Analyzer extends Transformer implements Modifiers, Kinds {
 		defineTemplate(templ, clazz, new Scope());
 		clazz.setInfo(templ.type);
 		((ModuleDef) tree).tpe = tpe = transform(tpe, TYPEmode);
+		if (tpe != Tree.Empty)
+		    clazz.setTypeOfThis(new LazySelfType(tpe));
 		owntype = (tpe == Tree.Empty) ? clazz.type() : tpe.type;
 		break;
 
@@ -1062,12 +1064,12 @@ public class Analyzer extends Transformer implements Modifiers, Kinds {
 	    case AliasTypeDef(int mods, Name name, AbsTypeDef[] tparams, Tree rhs):
 		pushContext(tree, sym.primaryConstructor(), new Scope(context.scope));
 		Symbol[] tparamSyms = enterParams(tparams);
-		((AliasTypeDef) tree).rhs = rhs = transform(rhs, TYPEmode);
-		owntype = rhs.type;
 		sym.primaryConstructor().setInfo(
 		    Type.PolyType(tparamSyms, sym.typeConstructor()));
 		// necessary so that we can access tparams
 		sym.primaryConstructor().flags |= INITIALIZED;
+		((AliasTypeDef) tree).rhs = rhs = transform(rhs, TYPEmode);
+		owntype = rhs.type;
 
 		popContext();
 		break;
@@ -1220,7 +1222,7 @@ public class Analyzer extends Transformer implements Modifiers, Kinds {
 	}
 	if ((mode & PATTERNmode) != 0) {
 	    if (tree.isType()) {
-		Symbol clazz = tree.type.unalias().symbol();
+		Symbol clazz = tree.type.withDefaultArgs().unalias().symbol();
 
 		if (clazz.isCaseClass()) {
 		    // set type to instantiated case class constructor
@@ -1655,9 +1657,10 @@ public class Analyzer extends Transformer implements Modifiers, Kinds {
 		    argpts[i] = formals[i].subst(tparams, targs);
 
  		// transform arguments with [targs/tparams]formals as prototypes
-		for (int i = 0; i < args.length; i++)
+		for (int i = 0; i < args.length; i++) {
 		    args[i] = transform(
 			args[i], argMode | POLYmode, formals[i].subst(tparams, targs));
+		}
 
 		// targs1: same as targs except that every AnyType is mapped to
 		// formal parameter type.
@@ -1817,6 +1820,9 @@ public class Analyzer extends Transformer implements Modifiers, Kinds {
 		sym.moduleClass().initialize();
 		Tree tpe1 = transform(tpe, TYPEmode);
 		Tree.Template templ1 = transformTemplate(templ, sym.moduleClass());
+		if (tpe1 != Tree.Empty && !templ1.type.isSubType(tpe1.type))
+		    error(tree.pos,
+			sym + " does not implement " + tpe1.type);
 		return copy.ModuleDef(tree, sym, tpe1, templ1)
 		    .setType(definitions.UNIT_TYPE);
 
@@ -2098,8 +2104,22 @@ public class Analyzer extends Transformer implements Modifiers, Kinds {
 		}
 
 	    case Typed(Tree expr, Tree tpe):
-		Tree tpe1 = transform(tpe, TYPEmode);
-		Tree expr1 = transform(expr, mode & baseModes, tpe1.type);
+		Tree expr1;
+		Tree tpe1;
+		switch (tpe) {
+		case Ident(TypeNames.WILDCARD_STAR):
+		    expr1 = transform(
+			expr, mode & baseModes, definitions.seqType(pt));
+		    Type[] elemtps = expr1.type.baseType(definitions.SEQ_CLASS).
+			typeArgs();
+		    Type elemtp = (elemtps.length == 1) ? elemtps[0]
+			: Type.ErrorType;
+		    tpe1 = tpe.setType(elemtp);
+		    break;
+		default:
+		    tpe1 = transform(tpe, TYPEmode);
+		    expr1 = transform(expr, mode & baseModes, tpe1.type);
+		}
 		return copy.Typed(tree, expr1, tpe1).setType(tpe1.type);
 
 	    case Function(Tree.ValDef[] vparams, Tree body):
@@ -2166,7 +2186,7 @@ public class Analyzer extends Transformer implements Modifiers, Kinds {
 		    Symbol tsym = TreeInfo.methSymbol(fn1);
 		    if (tsym.kind != ERROR) {
 			assert tsym.isType() : tsym;
-			switch (fn1.type.unalias()) {
+			switch (fn1.type.withDefaultArgs().unalias()) {
 			case TypeRef(Type pre, Symbol c, Type[] argtypes):
 			    if (c.kind != CLASS) {
 				error(tree.pos,
@@ -2199,7 +2219,7 @@ public class Analyzer extends Transformer implements Modifiers, Kinds {
 					fn1.type = Type.PolyType(
 					    tsym.typeParams(), fn1.type);
 				}
-				//System.out.println(TreeInfo.methSymbol(fn1) + ":" + tp + " --> " + fn1.type + " of " + fn1);//DEBUG
+				//System.out.println(TreeInfo.methSymbol(fn1) + " --> " + fn1.type + " of " + fn1);//DEBUG
 				selfcc = TreeInfo.isSelfConstrCall(fn0);
 			    }
 			    break;
diff --git a/sources/scalac/typechecker/RefCheck.java b/sources/scalac/typechecker/RefCheck.java
index 9c493db761..5178c3b703 100644
--- a/sources/scalac/typechecker/RefCheck.java
+++ b/sources/scalac/typechecker/RefCheck.java
@@ -105,30 +105,34 @@ public class RefCheck extends Transformer implements Modifiers, Kinds {
 	if ((other.flags & PRIVATE) == 0) {
 	    Symbol member1 = clazz.info().lookup(other.name);
 	    if (member1.kind != NONE && member1.owner() != other.owner()) {
-		Type self = clazz.thisType();
-		Type otherinfo = normalizedInfo(self, other);
-		Type template = resultToAny(otherinfo);
-		switch (member1.info()) {
-		case OverloadedType(Symbol[] alts, _):
-		    for (int i = 0; i < alts.length; i++) {
-			if (normalizedInfo(self, alts[i]).isSubType(template)) {
-			    if (member == other)
-				member = alts[i];
-			    else
-				unit.error(
-				    pos,
-				    "ambiguous override: both " +
-				    member + ":" + normalizedInfo(self, member) +
-				    "\n and " + alts[i] + ":" + normalizedInfo(self, alts[i]) +
-				    "\n override " + other + ":" + otherinfo +
-				    other.locationString());
+		if (member1.kind == VAL) {
+		    Type self = clazz.thisType();
+		    Type otherinfo = normalizedInfo(self, other);
+		    Type template = resultToAny(otherinfo);
+		    switch (member1.info()) {
+		    case OverloadedType(Symbol[] alts, _):
+			for (int i = 0; i < alts.length; i++) {
+			    if (normalizedInfo(self, alts[i]).isSubType(template)) {
+				if (member == other)
+				    member = alts[i];
+				else
+				    unit.error(
+					pos,
+					"ambiguous override: both " +
+					member + ":" + normalizedInfo(self, member) +
+					"\n and " + alts[i] + ":" + normalizedInfo(self, alts[i]) +
+					"\n override " + other + ":" + otherinfo +
+					other.locationString());
+			    }
+			}
+			break;
+		    default:
+			if (normalizedInfo(self, member1).isSubType(template)) {
+			    member = member1;
 			}
 		    }
-		    break;
-		default:
-		    if (normalizedInfo(self, member1).isSubType(template)) {
-			member = member1;
-		    }
+		} else {
+		    member = member1;
 		}
 	    }
 	    if (member != other) {
@@ -209,14 +213,27 @@ public class RefCheck extends Transformer implements Modifiers, Kinds {
 		       "\n an overriding definition in the current template is required");
 	} else {
 	    Type self = clazz.thisType();
+
 	    switch (other.kind) {
 	    case CLASS:
  		overrideError(pos, member, other, "cannot override a class");
 		break;
 	    case ALIAS:
+		if (member.typeParams().length != 0)
+		    overrideError(pos, member, other, "may not be parameterized");
+		if (other.typeParams().length != 0)
+		    overrideError(pos, member, other, "may not override parameterized type");
 		if (!self.memberType(member).isSameAs(self.memberType(other)))
 		    overrideTypeError(pos, member, other, self, false);
 		break;
+	    case TYPE:
+		if (member.typeParams().length != 0)
+		    overrideError(pos, member, other, "may not be parameterized");
+		if (!self.memberInfo(member).isSubType(self.memberInfo(other)))
+		    overrideTypeError(pos, member, other, self, false);
+		if (!self.memberLoBound(other).isSubType(self.memberLoBound(member)))
+		    overrideTypeError(pos, member, other, self, true);
+		break;
 	    default:
 		if (other.isConstructor())
 		    overrideError(pos, member, other,
@@ -224,11 +241,6 @@ public class RefCheck extends Transformer implements Modifiers, Kinds {
 		if (!normalizedInfo(self, member).isSubType(
 			normalizedInfo(self, other)))
 		    overrideTypeError(pos, member, other, self, false);
-		if (member.kind == TYPE &&
-		    !self.memberLoBound(other).isSubType(
-			 self.memberLoBound(member)))
-		    overrideTypeError(pos, member, other, self, true);
-
 	    }
 	}
     }
@@ -911,7 +923,7 @@ public class RefCheck extends Transformer implements Modifiers, Kinds {
 	    return super.transform(tree);
 
 	case AliasTypeDef(_, _, _, _):
-	    validateVariance(sym, sym.info(), NoVariance);
+	    validateVariance(sym, sym.info(), CoVariance);
 	    return super.transform(tree);
 
 	case Template(Tree[] bases, Tree[] body):
@@ -942,11 +954,11 @@ public class RefCheck extends Transformer implements Modifiers, Kinds {
 	    return super.transform(tree);
 
 	case Apply(Tree fn, Tree[] args):
+	    // convert case methods to new's
 	    Symbol fsym = TreeInfo.methSymbol(fn);
 	    assert fsym != Symbol.NONE : tree;
 	    if (fsym != null && fsym.isMethod() && !fsym.isConstructor() &&
 		(fsym.flags & CASE) != 0) {
-		// convert case methods to new's
 		Symbol constr = fsym.type().resultType().symbol().primaryConstructor();
 		tree = gen.New(toConstructor(tree, constr));
 	    }
@@ -965,13 +977,16 @@ public class RefCheck extends Transformer implements Modifiers, Kinds {
 	    return elimTypeNode(super.transform(tree));
 
 	case Ident(Name name):
+	    if (name == TypeNames.WILDCARD_STAR)
+		return tree;
+
 	    if( TreeInfo.isWildcardPattern( tree ) )
 		return elimTypeNode(tree);
 
 	    //System.out.println("name: "+name);
 	    Scope.Entry e = scopes[level].lookupEntry(name);
 	    //System.out.println("sym: "+sym);
-	    if (sym != null && sym.isLocal() && sym == e.sym) {
+	    if (sym.isLocal() && sym == e.sym) {
 		int i = level;
 		while (scopes[i] != e.owner) i--;
 		int symindex = ((Integer) symIndex.get(tree.symbol())).intValue();