caseclasses implement Product directly

caseclasses do not implement ProductN anymore

5 files changed, 32 insertions, 28 deletions

diff --git a/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala b/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala
index 67cd870036..f40a759dc3 100644
--- a/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala
+++ b/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala
@@ -1903,13 +1903,7 @@ trait Parsers requires SyntaxAnalyzer {
         if (name != nme.ScalaObject.toTypeName)
           parents += scalaScalaObjectConstr
         if (mods.hasFlag(Flags.CASE)) {
-          if (!vparamss.isEmpty) {
-            val argtypes: List[Tree] = vparamss.head map (.tpt.duplicate) //remove type annotation and you will get an interesting error message!!!
-            checkSize("case class parameters", argtypes.length, definitions.MaxProductArity)
-            if (argtypes.length <= definitions.MaxProductArity) parents += productConstr(argtypes)
-          } else {
-            parents += productConstr(Nil)
-          }
+          parents += productConstr
         }
         val ps = parents.toList
         newLineOptWhenFollowedBy(LBRACE)
diff --git a/src/compiler/scala/tools/nsc/ast/parser/TreeBuilder.scala b/src/compiler/scala/tools/nsc/ast/parser/TreeBuilder.scala
index 0aec97dcdd..3fe1bd28b8 100644
--- a/src/compiler/scala/tools/nsc/ast/parser/TreeBuilder.scala
+++ b/src/compiler/scala/tools/nsc/ast/parser/TreeBuilder.scala
@@ -27,16 +27,8 @@ abstract class TreeBuilder {
     scalaDot(nme.Unit.toTypeName)
   def scalaScalaObjectConstr: Tree =
     scalaDot(nme.ScalaObject.toTypeName)
-
-  def productConstr(typeArgs: List[Tree]) = {
-    def repeatedToSeq(tpt: Tree) = tpt match {
-      case AppliedTypeTree(Select(qual, name), args) if (name == nme.REPEATED_PARAM_CLASS_NAME.toTypeName) =>
-        AppliedTypeTree(Select(qual, nme.Seq.toTypeName), args)
-      case _ =>
-        tpt
-    }
-    AppliedTypeTree(scalaDot(newTypeName("Product"+typeArgs.length)), typeArgs map repeatedToSeq)
-  }
+  def productConstr: Tree =
+    scalaDot(nme.Product.toTypeName)
 
   /** Convert all occurrences of (lower-case) variables in a pattern as follows:
    *    x                  becomes      x @ _
diff --git a/src/compiler/scala/tools/nsc/backend/icode/Opcodes.scala b/src/compiler/scala/tools/nsc/backend/icode/Opcodes.scala
index d92106e52e..f6bed76977 100644
--- a/src/compiler/scala/tools/nsc/backend/icode/Opcodes.scala
+++ b/src/compiler/scala/tools/nsc/backend/icode/Opcodes.scala
@@ -335,9 +335,9 @@ trait Opcodes requires ICodes {
      * Stack: ...:size(int)
      *    ->: ...:arrayref
      */
-    case class CREATE_ARRAY(element: TypeKind) extends Instruction {
+    case class CREATE_ARRAY(elem: TypeKind) extends Instruction {
       /** Returns a string representation of this instruction */
-      override def toString(): String ="CREATE_ARRAY "+element.toString();
+      override def toString(): String ="CREATE_ARRAY "+elem.toString();
 
       override def consumed = 1;
       override def produced = 1;
diff --git a/src/compiler/scala/tools/nsc/symtab/StdNames.scala b/src/compiler/scala/tools/nsc/symtab/StdNames.scala
index 29dc359287..fee88151f2 100644
--- a/src/compiler/scala/tools/nsc/symtab/StdNames.scala
+++ b/src/compiler/scala/tools/nsc/symtab/StdNames.scala
@@ -205,6 +205,7 @@ trait StdNames requires SymbolTable {
     val Object = newTermName("Object")
     val PartialFunction = newTermName("PartialFunction")
     val Predef = newTermName("Predef")
+    val Product = newTermName("Product")
     val ScalaObject = newTermName("ScalaObject")
     val ScalaRunTime = newTermName("ScalaRunTime")
     val Seq = newTermName("Seq")
@@ -235,9 +236,8 @@ trait StdNames requires SymbolTable {
     val booleanValue = newTermName("booleanValue")
     val box = newTermName("box")
     val boxArray = newTermName("boxArray")
-    val caseArity = newTermName("caseArity")
-    val caseElement = newTermName("caseElement")
-    val caseName = newTermName("caseName")
+    val arity = newTermName("arity")
+    val element = newTermName("element")
     val checkCastability = newTermName("checkCastability")
     val classOf = newTermName("classOf")
     val coerce = newTermName("coerce")
diff --git a/src/compiler/scala/tools/nsc/typechecker/SyntheticMethods.scala b/src/compiler/scala/tools/nsc/typechecker/SyntheticMethods.scala
index 1a714600c0..b9f31edec7 100644
--- a/src/compiler/scala/tools/nsc/typechecker/SyntheticMethods.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/SyntheticMethods.scala
@@ -12,7 +12,7 @@ import scala.collection.mutable.ListBuffer
 
 /** <ul>
  *    <li>
- *      <code>caseArity</code>, <code>caseElement</code> implementations added
+ *      <code>productArity</code>, <code>element</code> implementations added
  *      to case classes
  *    </li>
  *    <li>
@@ -61,16 +61,34 @@ trait SyntheticMethods requires Analyzer {
       method
     }
 
+    /*
     def productSelectorMethod(n: int, accessor: Symbol): Tree = {
       val method = syntheticMethod(newTermName("_"+n), FINAL, accessor.tpe)
       typed(DefDef(method, vparamss => gen.mkAttributedRef(accessor)))
     }
-
+    */
     def productPrefixMethod: Tree = {
       val method = syntheticMethod(nme.productPrefix, FINAL, PolyType(List(), StringClass.tpe))
       typed(DefDef(method, vparamss => Literal(Constant(clazz.name.decode))))
     }
 
+    def productArityMethod(nargs:Int ): Tree = {
+      val method = syntheticMethod(nme.arity, FINAL, PolyType(List(), IntClass.tpe))
+      typed(DefDef(method, vparamss => Literal(Constant(nargs))))
+    }
+
+    def productElementMethod(accs: List[Symbol]): Tree = {
+      val method = syntheticMethod(nme.element, FINAL, MethodType(List(IntClass.tpe), AnyClass.tpe))
+      typed(DefDef(method, vparamss => Match(Ident(vparamss.head.head), {
+	(for(val Pair(sym,i) <- accs.zipWithIndex) yield {
+	  CaseDef(Literal(Constant(i)),EmptyTree, Ident(sym))
+	}):::List(CaseDef(Ident(nme.WILDCARD), EmptyTree,
+		    Throw(New(TypeTree(IndexOutOfBoundsExceptionClass.tpe), List(List(
+		      Select(Ident(vparamss.head.head), nme.toString_)
+		    ))))))
+      })))
+    }
+
     def moduleToStringMethod: Tree = {
       val method = syntheticMethod(nme.toString_, FINAL, MethodType(List(), StringClass.tpe))
       typed(DefDef(method, vparamss => Literal(Constant(clazz.name.decode))))
@@ -211,10 +229,10 @@ trait SyntheticMethods requires Analyzer {
 
         if (!hasDirectImplementation(nme.productPrefix)) ts += productPrefixMethod
 	val accessors = clazz.caseFieldAccessors
-        for (val i <- 0 until accessors.length) {
-          val acc = accessors(i)
-          if (acc.name.toString != "_"+(i+1)) ts += productSelectorMethod(i+1, acc)
-        }
+	if (!hasImplementation(nme.arity))
+	  ts += productArityMethod(accessors.length)
+	if (!hasImplementation(nme.element))
+	  ts += productElementMethod(accessors)
       }
 
       if (clazz.isModuleClass && isSerializable(clazz)) {