Merge pull request scala#6972 from cb372/productElementName

Product element name

Author: lrytz

src/compiler/scala/tools/nsc/typechecker/SyntheticMethods.scala

@@ -38,7 +38,7 @@ trait SyntheticMethods extends ast.TreeDSL {
   import definitions._
   import CODE._
 
-  private lazy val productSymbols    = List(Product_productPrefix, Product_productArity, Product_productElement, Product_iterator, Product_canEqual)
+  private lazy val productSymbols    = List(Product_productPrefix, Product_productArity, Product_productElement, Product_productElementName, Product_iterator, Product_canEqual)
   private lazy val valueSymbols      = List(Any_hashCode, Any_equals)
   private lazy val caseSymbols       = List(Object_hashCode, Object_toString) ::: productSymbols
   private lazy val caseValueSymbols  = Any_toString :: valueSymbols ::: productSymbols
@@ -117,11 +117,13 @@ trait SyntheticMethods extends ast.TreeDSL {
       )
     }
 
-    /* Common code for productElement and (currently disabled) productElementName */
     def perElementMethod(name: Name, returnType: Type)(caseFn: Symbol => Tree): Tree =
       createSwitchMethod(name, accessors.indices, returnType)(idx => caseFn(accessors(idx)))
 
-    // def productElementNameMethod = perElementMethod(nme.productElementName, StringTpe)(x => LIT(x.name.toString))
+    def productElementNameMethod = {
+      val constrParamAccessors = clazz.constrParamAccessors
+      createSwitchMethod(nme.productElementName, constrParamAccessors.indices, StringTpe)(idx => LIT(constrParamAccessors(idx).name.dropLocal.decode))
+    }
 
     var syntheticCanEqual = false
 
@@ -248,14 +250,12 @@ trait SyntheticMethods extends ast.TreeDSL {
     // methods for both classes and objects
     def productMethods = {
       List(
-        Product_productPrefix   -> (() => constantNullary(nme.productPrefix, clazz.name.decode)),
-        Product_productArity    -> (() => constantNullary(nme.productArity, arity)),
-        Product_productElement  -> (() => perElementMethod(nme.productElement, AnyTpe)(mkThisSelect)),
-        Product_iterator        -> (() => productIteratorMethod),
-        Product_canEqual        -> (() => canEqualMethod)
-        // This is disabled pending a reimplementation which doesn't add any
-        // weight to case classes (i.e. inspects the bytecode.)
-        // Product_productElementName  -> (() => productElementNameMethod(accessors)),
+        Product_productPrefix       -> (() => constantNullary(nme.productPrefix, clazz.name.decode)),
+        Product_productArity        -> (() => constantNullary(nme.productArity, arity)),
+        Product_productElement      -> (() => perElementMethod(nme.productElement, AnyTpe)(mkThisSelect)),
+        Product_productElementName  -> (() => productElementNameMethod),
+        Product_iterator            -> (() => productIteratorMethod),
+        Product_canEqual            -> (() => canEqualMethod)
       )
     }
 

src/library/scala/Product.scala

@@ -48,4 +48,24 @@ trait Product extends Any with Equals {
    *  @return   in the default implementation, the empty string
    */
   def productPrefix = ""
+
+  /** The name of the n^th^ element of this product, 0-based.
+   *  In the default implementation, an empty string.
+   *
+   *  @param    n   the index of the element name to return
+   *  @throws       IndexOutOfBoundsException
+   *  @return       the name of the specified element
+   */
+  def productElementName(n: Int): String =
+    if (n >= 0 && n < productArity) ""
+    else throw new IndexOutOfBoundsException(n.toString)
+
+  /** An iterator over the names of all the elements of this product.
+   */
+  def productElementNames: Iterator[String] = new scala.collection.AbstractIterator[String] {
+    private[this] var c: Int = 0
+    private[this] val cmax = productArity
+    def hasNext = c < cmax
+    def next() = { val result = productElementName(c); c += 1; result }
+  }
 }

src/reflect/scala/reflect/internal/Definitions.scala

@@ -749,6 +749,7 @@ trait Definitions extends api.StandardDefinitions {
     lazy val ProductRootClass: ClassSymbol = requiredClass[scala.Product]
       def Product_productArity          = getMemberMethod(ProductRootClass, nme.productArity)
       def Product_productElement        = getMemberMethod(ProductRootClass, nme.productElement)
+      def Product_productElementName    = getMemberMethod(ProductRootClass, nme.productElementName)
       def Product_iterator              = getMemberMethod(ProductRootClass, nme.productIterator)
       def Product_productPrefix         = getMemberMethod(ProductRootClass, nme.productPrefix)
       def Product_canEqual              = getMemberMethod(ProductRootClass, nme.canEqual_)

src/reflect/scala/reflect/internal/StdNames.scala

@@ -771,6 +771,7 @@ trait StdNames {
     val prefix : NameType              = "prefix"
     val productArity: NameType         = "productArity"
     val productElement: NameType       = "productElement"
+    val productElementName: NameType   = "productElementName"
     val productIterator: NameType      = "productIterator"
     val productPrefix: NameType        = "productPrefix"
     val raw_ : NameType                = "raw"

test/files/run/idempotency-case-classes.check

@@ -20,6 +20,11 @@ C(2,3)
       case 1 => C.this.y
       case _ => throw new IndexOutOfBoundsException(x$1.toString())
     };
+    override <synthetic> def productElementName(x$1: Int): String = x$1 match {
+      case 0 => "x"
+      case 1 => "y"
+      case _ => throw new IndexOutOfBoundsException(x$1.toString())
+    };
     override <synthetic> def productIterator: Iterator[Any] = scala.runtime.ScalaRunTime.typedProductIterator[Any](C.this);
     <synthetic> def canEqual(x$1: Any): Boolean = x$1.$isInstanceOf[C]();
     override <synthetic> def hashCode(): Int = {

test/files/run/macroPlugins-namerHooks.check

@@ -37,6 +37,8 @@ enterSym(super.<init>())
 enterStat(super.<init>())
 enterSym(case <synthetic> val x1: Int = x$1)
 enterStat(case <synthetic> val x1: Int = x$1)
+enterSym(case <synthetic> val x1: Int = x$1)
+enterStat(case <synthetic> val x1: Int = x$1)
 enterSym(case <synthetic> val x1: Any = x$1)
 enterSym(case5(){   if (x1.isInstanceOf[C])     matchEnd4(true)   else     case6() })
 enterSym(case6(){   matchEnd4(false) })

test/files/run/productElementName.check

@@ -0,0 +1,14 @@
+User(name=Susan, age=42)
+ユーザ(名前=Susan, 年齢=42)
+U$er(na$me=Susan, a$ge=42)
+type(for=Susan, if=42)
+contains spaces(first param=Susan, second param=42)
+Symbols(::=Susan, ||=42)
+MultipleParamLists(a=Susan, b=42)
+AuxiliaryConstructor(a=Susan, b=42)
+OverloadedApply(a=Susan, b=123)
+DefinesProductElementName(foo=Susan, foo=42)
+InheritsProductElementName(a=Susan, b=42)
+InheritsProductElementName_Override(overriden=Susan, overriden=42)
+InheritsProductElementName_Override_SelfType(a=Susan, b=42)
+PrivateMembers(a=10, b=20, c=30, d=40, e=50, f=60)

test/files/run/productElementName.scala

@@ -0,0 +1,77 @@
+
+case class User(name: String, age: Int)
+
+case class ユーザ(名前: String, 年齢: Int)
+
+case class U$er(na$me: String, a$ge: Int)
+
+case class `type`(`for`: String, `if`: Int)
+
+case class `contains spaces`(`first param`: String, `second param`: Int)
+
+case class Symbols(:: : String, || : Int)
+
+case class MultipleParamLists(a: String, b: Int)(c: Boolean)
+
+case class AuxiliaryConstructor(a: String, b: Int) {
+  def this(x: String) {
+    this(x, 123)
+  }
+}
+
+case class OverloadedApply(a: String, b: Int)
+object OverloadedApply {
+  def apply(x: String): OverloadedApply =
+    new OverloadedApply(x, 123)
+}
+
+case class DefinesProductElementName(a: String, b: Int) {
+  override def productElementName(n: Int): String = "foo"
+}
+
+trait A {
+  def productElementName(n: Int): String = "overriden"
+}
+case class InheritsProductElementName(a: String, b: Int) extends A
+
+trait B extends Product {
+  override def productElementName(n: Int): String = "overriden"
+}
+case class InheritsProductElementName_Override(a: String, b: Int) extends B
+
+trait C { self: Product =>
+  override def productElementName(n: Int): String = "overriden"
+}
+case class InheritsProductElementName_Override_SelfType(a: String, b: Int) extends C
+
+case class PrivateMembers(a: Int, private val b: Int, c: Int, private val d: Int, e: Int, private val f: Int)
+
+object Test extends App {
+  def pretty(p: Product): String =
+    p.productElementNames.zip(p.productIterator)
+     .map { case (name, value) => s"$name=$value" }
+     .mkString(p.productPrefix + "(", ", ", ")")
+
+  println(pretty(User("Susan", 42)))
+  println(pretty(ユーザ("Susan", 42)))
+  println(pretty(U$er("Susan", 42)))
+  println(pretty(`type`("Susan", 42)))
+  println(pretty(`contains spaces`("Susan", 42)))
+  println(pretty(Symbols("Susan", 42)))
+  println(pretty(MultipleParamLists("Susan", 42)(true)))
+  println(pretty(AuxiliaryConstructor("Susan", 42)))
+  println(pretty(OverloadedApply("Susan")))
+  println(pretty(DefinesProductElementName("Susan", 42)))
+
+  // uses the synthetic, not the one defined in the trait
+  println(pretty(InheritsProductElementName("Susan", 42)))
+
+  // uses the override defined in the trait
+  println(pretty(InheritsProductElementName_Override("Susan", 42)))
+
+  // uses the synthetic, not the one defined in the trait
+  println(pretty(InheritsProductElementName_Override_SelfType("Susan", 42)))
+
+  println(pretty(PrivateMembers(10, 20, 30, 40, 50, 60)))
+}
+

test/files/scalap/caseClass.check

@@ -6,6 +6,7 @@ case class CaseClass[A <: scala.Seq[scala.Int]](i: A, s: scala.Predef.String) ex
   override def productPrefix: java.lang.String = { /* compiled code */ }
   def productArity: scala.Int = { /* compiled code */ }
   def productElement(x$1: scala.Int): scala.Any = { /* compiled code */ }
+  override def productElementName(x$1: scala.Int): java.lang.String = { /* compiled code */ }
   override def productIterator: scala.collection.Iterator[scala.Any] = { /* compiled code */ }
   def canEqual(x$1: scala.Any): scala.Boolean = { /* compiled code */ }
   override def hashCode(): scala.Int = { /* compiled code */ }

test/files/scalap/caseObject.check

@@ -3,6 +3,7 @@ case object CaseObject extends scala.AnyRef with scala.Product with scala.Serial
   override def productPrefix: java.lang.String = { /* compiled code */ }
   def productArity: scala.Int = { /* compiled code */ }
   def productElement(x$1: scala.Int): scala.Any = { /* compiled code */ }
+  override def productElementName(x$1: scala.Int): java.lang.String = { /* compiled code */ }
   override def productIterator: scala.collection.Iterator[scala.Any] = { /* compiled code */ }
   def canEqual(x$1: scala.Any): scala.Boolean = { /* compiled code */ }
   override def hashCode(): scala.Int = { /* compiled code */ }