*** empty log message ***

15 files changed, 102 insertions, 33 deletions

diff --git a/sources/scala/runtime/matching/Match.scala b/sources/scala/runtime/matching/Match.scala
index 6674c3157a..e0df7332ac 100644
--- a/sources/scala/runtime/matching/Match.scala
+++ b/sources/scala/runtime/matching/Match.scala
@@ -61,7 +61,7 @@ object Match {
 
 class Match( k:Int,it:Iterator[Seq[scala.xml.Node]] ) {
 
-  def equals( o:Object ) = o match {
+  override def equals( o:Any ) = o match {
     case that:Match =>
     ( this.index == that.index )&&( this.iter.toList == that.iter.toList )
     case _ => false;
diff --git a/sources/scala/tools/scalac/transformer/TransMatch.scala b/sources/scala/tools/scalac/transformer/TransMatch.scala
index a86c63e9cb..8ee50d5493 100644
--- a/sources/scala/tools/scalac/transformer/TransMatch.scala
+++ b/sources/scala/tools/scalac/transformer/TransMatch.scala
@@ -163,7 +163,7 @@ class TransMatch( global:scalac_Global )
        return null;
      else
        tree match {
-         case Tree$Apply(Tree$Select( receiver, Names.match ), args) =>
+         case Tree$Apply(Tree$Select( receiver, Names._match ), args) =>
            if ((args != null) && (args.length == 1))
              args( 0 ) match {
                case Tree$Visitor( cases ) =>
@@ -171,7 +171,7 @@ class TransMatch( global:scalac_Global )
              }
            return tree;
 
-         case Tree$Apply(Tree$TypeApply(Tree$Select( receiver, Names.match ), targs), args) =>
+         case Tree$Apply(Tree$TypeApply(Tree$Select( receiver, Names._match ), targs), args) =>
            if ((args != null) && (args.length == 1))
              args( 0 ) match {
                case Tree$Visitor( cases ) =>
diff --git a/sources/scala/tools/scalac/transformer/matching/MutableGrammar.scala b/sources/scala/tools/scalac/transformer/matching/MutableGrammar.scala
index 7a7c7e2b2c..56d4554751 100644
--- a/sources/scala/tools/scalac/transformer/matching/MutableGrammar.scala
+++ b/sources/scala/tools/scalac/transformer/matching/MutableGrammar.scala
@@ -63,7 +63,7 @@ case class MutableGrammar( treeRules:mutable.Set[TRule],
     } ;
   }
 
-  def toString:String = {
+  override def toString(): String = {
     val sb = new StringBuffer();
     sb.append( { if( treeRules.isEmpty )
       "Set of rules is EMPTY.\n" else treeRulesToString });
diff --git a/sources/scala/tools/scalac/typechecker/Analyzer.scala b/sources/scala/tools/scalac/typechecker/Analyzer.scala
index 5c973103d5..888dfe0c9f 100644
--- a/sources/scala/tools/scalac/typechecker/Analyzer.scala
+++ b/sources/scala/tools/scalac/typechecker/Analyzer.scala
@@ -2852,7 +2852,7 @@ class Analyzer(global: scalac_Global, descr: AnalyzerPhase) extends Transformer(
           }
 
 	case Tree$Select(qual, name) =>
-	  val qualmode: int = if (name == Names.match) EXPRmode
+	  val qualmode: int = if (name == Names._match) EXPRmode
                               else EXPRmode | POLYmode | QUALmode;
 	  var qual1: Tree = transform(qual, qualmode);
 	  if (name.isTypeName())
diff --git a/sources/scala/tools/scalac/typechecker/AnalyzerPhase.scala b/sources/scala/tools/scalac/typechecker/AnalyzerPhase.scala
index 5d99791f38..ec42694767 100644
--- a/sources/scala/tools/scalac/typechecker/AnalyzerPhase.scala
+++ b/sources/scala/tools/scalac/typechecker/AnalyzerPhase.scala
@@ -7,7 +7,8 @@
 // $Id$
 
 import scala.tools.util.Position;
-import scalac.{symtab => scalac_symtab, _}
+import scalac._;
+import scalac.symtab._;
 import scalac.util._;
 import scalac.ast._;
 import scalac.checkers._;
@@ -19,8 +20,6 @@ import scalac.{Global => scalac_Global}
 
 package scala.tools.scalac.typechecker {
 
-import scalac_symtab._;
-
 class AnalyzerPhase(global: scalac_Global, descriptor: PhaseDescriptor) extends scalac_AnalyzerPhase(global, descriptor) {
 
   var startContext = new Context(
diff --git a/sources/scala/tools/scalac/typechecker/ConstantFolder.scala b/sources/scala/tools/scalac/typechecker/ConstantFolder.scala
index a3e3470bdc..b8510ca0a9 100644
--- a/sources/scala/tools/scalac/typechecker/ConstantFolder.scala
+++ b/sources/scala/tools/scalac/typechecker/ConstantFolder.scala
@@ -12,7 +12,7 @@
 
 import java.lang.Object;
 
-import scalac.{symtab => scalac_symtab}
+import scalac.symtab._;
 import scalac.{Global => scalac_Global}
 import scalac.util.Name;
 import scalac.util.Names;
@@ -24,8 +24,6 @@ import scalac.atree.ATypeKind._;
 
 package scala.tools.scalac.typechecker {
 
-import scalac_symtab._;
-
 class ConstantFolder(global: scalac_Global) {
 
     //########################################################################
diff --git a/sources/scala/tools/scalac/typechecker/Context.scala b/sources/scala/tools/scalac/typechecker/Context.scala
index 8de7f321f5..81cf9a28c9 100644
--- a/sources/scala/tools/scalac/typechecker/Context.scala
+++ b/sources/scala/tools/scalac/typechecker/Context.scala
@@ -5,15 +5,13 @@
 **
 ** $Id$
 \*                                                                      */
-import scalac.{symtab => scalac_symtab}
+import scalac.symtab._;
 import scalac.ast._;
 import scalac.util.Names;
 import scalac.util.Name;
 
 package scala.tools.scalac.typechecker {
 
-import scalac_symtab._;
-
 object Context {
   val NONE = new Context();
   NONE.viewCache = List();
diff --git a/sources/scala/tools/scalac/typechecker/DeSugarize.scala b/sources/scala/tools/scalac/typechecker/DeSugarize.scala
index 64880003ae..7e178e3000 100644
--- a/sources/scala/tools/scalac/typechecker/DeSugarize.scala
+++ b/sources/scala/tools/scalac/typechecker/DeSugarize.scala
@@ -11,7 +11,7 @@ import java.lang.Object;
 
 import scalac._;
 import scalac.util._;
-import scalac.{symtab => scalac_symtab}
+import scalac.symtab._;
 import scalac.ast._;
 import scalac.typechecker.Infer;
 import scalac.{Global => scalac_Global, CompilationUnit => scalac_CompilationUnit}
@@ -21,8 +21,6 @@ import scala.tools.scalac.util.NewArray;
 
 package scala.tools.scalac.typechecker {
 
-import scalac_symtab._;
-
 /** A transformer for removing syntactic sugar. This transformer does
  *  not need any type or symbol-table information.
  *
@@ -210,7 +208,7 @@ class DeSugarize(make: TreeFactory, copy: TreeCopier, gen: TreeGen, infer: scala
       // x.match {cases}
       val body: Tree = make.Apply(
 	tree.pos,
-	make.Select(tree.pos, xuse, Names.match),
+	make.Select(tree.pos, xuse, Names._match),
 	NewArray.Tree(tree));
       make.Function(tree.pos, NewArray.ValDef(param), body);
   }
@@ -390,7 +388,7 @@ class DeSugarize(make: TreeFactory, copy: TreeCopier, gen: TreeGen, infer: scala
       val cases = NewArray.CaseDef(make.CaseDef(pos, pat, Tree.Empty, tuple));
       val match: Tree = make.Apply(
 	pos,
-	make.Select(pos, rhs, Names.match),
+	make.Select(pos, rhs, Names._match),
 	NewArray.Tree(make.Visitor(pos, cases)));
 
       if (vars.length == 0) {
diff --git a/sources/scala/tools/scalac/typechecker/Infer.scala b/sources/scala/tools/scalac/typechecker/Infer.scala
index fa2dac2c1f..ae6adbadef 100644
--- a/sources/scala/tools/scalac/typechecker/Infer.scala
+++ b/sources/scala/tools/scalac/typechecker/Infer.scala
@@ -9,7 +9,7 @@
 import java.lang.Object;
 
 import scalac.{Global => scalac_Global}
-import scalac.{symtab => scalac_symtab}
+import scalac.symtab._;
 import scalac.typechecker.{Infer => scalac_Infer}
 import scalac.ApplicationError;
 import scalac.util._;
@@ -21,8 +21,6 @@ import scala.tools.scalac.util.NewArray;
 
 package scala.tools.scalac.typechecker {
 
-import scalac_symtab._;
-
 class Infer(global: scalac_Global, gen: TreeGen, make: TreeFactory) extends scalac_Infer {
 
   import Modifiers._, Kinds._;
diff --git a/sources/scala/tools/scalac/typechecker/Substituter.scala b/sources/scala/tools/scalac/typechecker/Substituter.scala
index e30fed4444..cb358af63a 100644
--- a/sources/scala/tools/scalac/typechecker/Substituter.scala
+++ b/sources/scala/tools/scalac/typechecker/Substituter.scala
@@ -7,15 +7,13 @@
 // $Id$
 
 import scalac.{Global => scalac_Global};
-import scalac.{symtab => scalac_symtab}
+import scalac.symtab._;
 import scalac.ApplicationError;
 import scalac.util._;
 import scalac.ast._;
 
 package scala.tools.scalac.typechecker {
 
-import scalac_symtab._;
-
 // Tree Substitution -------------------------------------------------------------
 
 class Substituter(global: scalac_Global, gen: TreeGen) extends Transformer(global) {
diff --git a/sources/scalac/symtab/Definitions.java b/sources/scalac/symtab/Definitions.java
index 7d0d6ce0a7..9f4ff9cbe0 100644
--- a/sources/scalac/symtab/Definitions.java
+++ b/sources/scalac/symtab/Definitions.java
@@ -707,7 +707,7 @@ public class Definitions {
         // ANY_PLUS  = newMethod(ANY_CLASS,Names.PLUS        ,Modifiers.FINAL);
         ANY_IS       = newMethod(ANY_CLASS,Names.isInstanceOf,Modifiers.FINAL);
         ANY_AS       = newMethod(ANY_CLASS,Names.asInstanceOf,Modifiers.FINAL);
-        ANY_MATCH    = newMethod(ANY_CLASS,Names.match       ,Modifiers.FINAL);
+        ANY_MATCH    = newMethod(ANY_CLASS,Names._match      ,Modifiers.FINAL);
 
         initMethod(ANY_EQEQ    , new Type[]{ANY_TYPE()}   , boolean_TYPE());
         initMethod(ANY_BANGEQ  , new Type[]{ANY_TYPE()}   , boolean_TYPE());
diff --git a/sources/scalac/symtab/Symbol.java b/sources/scalac/symtab/Symbol.java
index 6c5ef821d0..5c518bc65c 100644
--- a/sources/scalac/symtab/Symbol.java
+++ b/sources/scalac/symtab/Symbol.java
@@ -1227,7 +1227,7 @@ public abstract class Symbol implements Modifiers, Kinds {
         private Type transformInfo(Phase phase, Type info) {
             Global global = phase.global;
             Phase current = global.currentPhase;
-            boolean keepInheritedOverloaded = current.id <= global.PHASE.REFCHECK.id();
+            boolean keepInheritedOverloaded = current.id <= global.PHASE.UNCURRY.id();
             switch (info) {
             case ErrorType:
             case NoType:
diff --git a/sources/scalac/transformer/UnCurry.java b/sources/scalac/transformer/UnCurry.java
index cf2cc46afc..0deb9fc3fc 100644
--- a/sources/scalac/transformer/UnCurry.java
+++ b/sources/scalac/transformer/UnCurry.java
@@ -123,11 +123,14 @@ public class UnCurry extends OwnerTransformer
 	}
         switch (tree) {
 	case ClassDef(_, _, AbsTypeDef[] tparams, ValDef[][] vparams, Tree tpe, Template impl):
+            Symbol clazz = tree.symbol();
+            for (Scope.SymbolIterator it = clazz.members().iterator(); it.hasNext(); )
+                checkNoDoubleDef(clazz, it.next());
 	    return copy.ClassDef(
-		tree, tree.symbol(), tparams,
-		uncurry(transform(vparams, tree.symbol())),
+		tree, clazz, tparams,
+		uncurry(transform(vparams, clazz)),
 		tpe,
-		transform(impl, tree.symbol()));
+		transform(impl, clazz));
 
 	case DefDef(_, _, AbsTypeDef[] tparams, ValDef[][] vparams, Tree tpe, Tree rhs):
 	    Symbol sym = tree.symbol();
@@ -173,7 +176,7 @@ public class UnCurry extends OwnerTransformer
 		!(args1[0] instanceof Tree.Visitor)) {
 		switch (TreeInfo.methPart(fn1)) {
 		case Select(Tree qual, Name name):
-		    assert name == Names.match;
+		    assert name == Names._match;
 		    return gen.postfixApply(qual, args1[0], currentOwner);
 		default:
 		    throw new ApplicationError("illegal prefix for match: " + tree);
@@ -324,4 +327,81 @@ public class UnCurry extends OwnerTransformer
 	    return transform(arg);
 	}
     }
+
+// Double Definition Checking -----------------------------------------------
+
+    private void checkNoDoubleDef(Symbol clazz, Symbol sym) {
+        switch (sym.type()) {
+        case OverloadedType(Symbol[] alts, Type[] alttypes):
+            for (int i = 0; i < alttypes.length; i++) {
+                for (int j = i + 1; j < alttypes.length; j++)
+                    if (inConflict(alts[i], alts[j], descr.uncurry(alttypes[i]), descr.uncurry(alttypes[j])))
+                        conflictError(clazz, alts[i], alts[j], alttypes[i], alttypes[j]);
+            }
+            break;
+        default:
+        }
+    }
+
+    private void conflictError(Symbol clazz, Symbol sym1, Symbol sym2, Type type1, Type type2) {
+        if (sym1.owner() == clazz && sym2.owner() == clazz)
+            unit.error(sym2.pos,
+                       "Double declaration:\n" +
+                       sym1 + ": " + type1 + " and\n" +
+                       sym2 + ": " + type2 + " have same types after erasure");
+        else if (sym1.owner() == clazz)
+            unit.error(sym1.pos,
+                       "Accidental override:\n" +
+                       sym1 + ": " + type1 + " has same type after erasure as\n" +
+                       sym2 + ": " + type2 + " which is inherited from " + sym2.owner());
+        else if (sym2.owner() == clazz)
+            unit.error(sym2.pos,
+                       "Accidental override:\n" +
+                       sym2 + ": " + type2 + " has same type after erasure as\n" +
+                       sym1 + ": " + type1 + " which is inherited from " + sym1.owner());
+        else
+            unit.error(clazz.pos,
+                       "Inheritance conflict: inherited members\n" +
+                      sym1 + ": " + type1 + sym1.locationString() + " and\n" +
+                       sym2 + ": " + type2 + sym2.locationString() + " have same types after erasure");
+    }
+
+    private boolean inConflict(Symbol sym1, Symbol sym2, Type type1, Type type2) {
+        switch (type1) {
+        case PolyType(_, Type restype1):
+            return inConflict(sym1, sym2, restype1, type2);
+
+        case MethodType(Symbol[] params1, Type restype1):
+            switch (type2) {
+            case PolyType(_, Type restype2):
+                return inConflict(sym1, sym2, type1, restype2);
+
+            case MethodType(Symbol[] params2, Type restype2):
+                if (params1.length != params2.length) return false;
+                for (int i = 0; i < params1.length; i++) {
+                    if (!params1[i].nextInfo().erasure().isSameAs(
+                            params2[i].nextInfo().erasure())) return false;
+                }
+                if (restype1.erasure().isSameAs(restype2.erasure()))
+                    return true;
+                if (sym1.owner() == sym2.owner())
+                    return false;
+                for (int i = 0; i < params1.length; i++) {
+                    if (!params1[i].nextInfo().isSameAs(
+                            params2[i].nextInfo())) return false;
+                }
+                return true;
+
+            default:
+                return false;
+            }
+
+        default:
+            switch (type2) {
+            case PolyType(_, _):
+            case MethodType(_, _): return inConflict(sym1, sym2, type2, type1);
+            default: return true;
+            }
+        }
+    }
 }
diff --git a/sources/scalac/transformer/UnCurryPhase.java b/sources/scalac/transformer/UnCurryPhase.java
index 44988064de..f94593b9ef 100644
--- a/sources/scalac/transformer/UnCurryPhase.java
+++ b/sources/scalac/transformer/UnCurryPhase.java
@@ -30,7 +30,7 @@ public class UnCurryPhase extends Phase implements Modifiers {
      *  - if symbol is a def parameter with transformed type T, return () => T
      */
     public Type transformInfo(Symbol sym, Type tp0) {
-	Type tp1 = uncurry(sym.removeInheritedOverloaded(tp0));
+	Type tp1 = uncurry(tp0);
 	if (sym.isDefParameter()) return global.definitions.FUNCTION_TYPE(Type.EMPTY_ARRAY, tp1);
 	else return tp1;
     }
diff --git a/sources/scalac/util/Names.java b/sources/scalac/util/Names.java
index 5cc607fa8f..6e93c4f1fb 100644
--- a/sources/scalac/util/Names.java
+++ b/sources/scalac/util/Names.java
@@ -164,7 +164,7 @@ public class Names {
     public static final Name java = Name.fromString("java");
     public static final Name lang = Name.fromString("lang");
     public static final Name length = Name.fromString("length");
-    public static final Name match = Name.fromString("match");
+    public static final Name _match = Name.fromString("match");
     public static final Name map = Name.fromString("map");
     public static final Name n = Name.fromString("n");
     public static final Name nobinding = Name.fromString("nobinding");