Merge pull request scala#6336 from hrhino/t10726

Right-associative arguments don't lose singleton type

Author: lrytz

src/compiler/scala/tools/nsc/ast/parser/Parsers.scala

@@ -848,10 +848,14 @@ self =>
       }
       if (isExpr) {
         if (rightAssoc) {
+          import symtab.Flags._
           val x = freshTermName(nme.RIGHT_ASSOC_OP_PREFIX)
+          val liftedArg = atPos(left.pos) {
+            ValDef(Modifiers(FINAL | SYNTHETIC | ARTIFACT), x, TypeTree(), stripParens(left))
+          }
           Block(
-            List(ValDef(Modifiers(symtab.Flags.SYNTHETIC | symtab.Flags.ARTIFACT), x, TypeTree(), stripParens(left))),
-            Apply(mkSelection(right), List(Ident(x))))
+            liftedArg :: Nil,
+            Apply(mkSelection(right), List(Ident(x) setPos left.pos.focus)))
         } else {
           Apply(mkSelection(left), arguments)
         }
@@ -2275,7 +2279,7 @@ self =>
       val vds   = new ListBuffer[List[ValDef]]
       val start = in.offset
       def paramClause(): List[ValDef] = if (in.token == RPAREN) Nil else {
-        val implicitmod = 
+        val implicitmod =
           if (in.token == IMPLICIT) {
             if (implicitOffset == -1) { implicitOffset = in.offset ; implicitSection = vds.length }
             else if (warnAt == -1) warnAt = in.offset

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

@@ -3639,13 +3639,28 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper
                   case _ => tp
                 }
 
-                // Inline RHS of ValDef for right-associative by-value operator desugaring
-                val (args2, pos2) = (args1, mt.params) match {
-                  case ((ident: Ident) :: Nil, param :: Nil) if param.isByNameParam && rightAssocValDefs.contains(ident.symbol) =>
-                    inlinedRightAssocValDefs += ident.symbol
-                    val rhs = rightAssocValDefs.remove(ident.symbol).get
-                    (rhs.changeOwner(ident.symbol -> context.owner) :: Nil, wrappingPos(tree :: rhs :: Nil))
-                  case _ => (args1, tree.pos)
+                // Inline RHS of ValDef for right-associative by-value operator desugaring.
+                // Remove the ValDef also if the argument is a constant-folded reference to it.
+                var (args2, pos2) = (args1, tree.pos)
+                args1 match {
+                  case List(lit: Literal) =>
+                    lit.attachments.get[OriginalTreeAttachment] match {
+                      case Some(OriginalTreeAttachment(id: Ident)) if rightAssocValDefs.contains(id.symbol) =>
+                        inlinedRightAssocValDefs += id.symbol
+                        rightAssocValDefs.remove(id.symbol)
+                      case _ =>
+                    }
+
+                  case List(id: Ident) if rightAssocValDefs.contains(id.symbol) =>
+                    mt.params match {
+                      case List(p) if p.isByNameParam =>
+                        inlinedRightAssocValDefs += id.symbol
+                        val rhs = rightAssocValDefs.remove(id.symbol).get
+                        args2 = rhs.changeOwner(id.symbol -> context.owner) :: Nil
+                        pos2 = wrappingPos(tree :: rhs :: Nil)
+                      case _ =>
+                    }
+                  case _ =>
                 }
 
                 /*

test/files/pos/t10726.scala

@@ -0,0 +1,8 @@
+object Test {
+
+  def eat(foods: List["food"]): Unit = println(s"ate ${foods.size} foods")
+
+  eat("food" :: Nil)
+  eat(Nil.::("food"))
+
+}

test/files/run/t10751.check

@@ -1,15 +1,36 @@
 [[syntax trees at end of                     typer]] // newSource1.scala
-[0:56]package [0:0]<empty> {
-  [0:56]object Test extends [12:56][56]scala.AnyRef {
-    [56]def <init>(): [12]Test.type = [56]{
-      [56][56][56]Test.super.<init>();
+[0:201]package [0:0]<empty> {
+  [0:201]object Test extends [12:201][201]scala.AnyRef {
+    [201]def <init>(): [12]Test.type = [201]{
+      [201][201][201]Test.super.<init>();
       [12]()
     };
-    [20:29]{
-      [20:29]<22:29><22:29>C.foo_:[[22]Nothing]([20:21]1)
+    [20:43]private[this] val n: [38]Int = [42:43]1;
+    [51:60]{
+      [53:60]<53:60><53:60>C.foo_:[[53]Nothing]([51]1)
     };
-    [36:50]{
-      [36:50]<38:50><38:50>C.foo_:[[44:47]<type: [44:47]scala.Any>]([36:37]1)
+    [67:81]{
+      [69:81]<69:81><69:81>C.foo_:[[75:78]<type: [75:78]scala.Any>]([67]1)
+    };
+    [89:98]{
+      [89:98]<91:98><91:98>C.foo_:[[91]Nothing]([89:90][89]Test.this.n)
+    };
+    [105:119]{
+      [105:119]<107:119><107:119>C.foo_:[[113:116]<type: [113:116]scala.Any>]([105:106][105]Test.this.n)
+    };
+    [127:136]{
+      [129:136]<129:136><129:136>C.bar_:[[129]Nothing]([127]1)
+    };
+    [143:157]{
+      [145:157]<145:157><145:157>C.bar_:[[151:154]<type: [151:154]scala.Any>]([143]1)
+    };
+    [165:174]{
+      [165:166]final <synthetic> <artifact> val rassoc$7: [165]Int = [165:166][165]Test.this.n;
+      [167:174]<167:174><167:174>C.bar_:[[167]Nothing]([165]rassoc$7)
+    };
+    [181:195]{
+      [181:182]final <synthetic> <artifact> val rassoc$8: [181]Int = [181:182][181]Test.this.n;
+      [183:195]<183:195><183:195>C.bar_:[[189:192]<type: [189:192]scala.Any>]([181]rassoc$8)
     }
   }
 }

test/files/run/t10751.scala

@@ -7,8 +7,19 @@ object Test extends DirectTest {
 
   override def code = """
     object Test {
+      private[this] val n = 1
+
       1 foo_: C
       1 foo_:[Any] C
+
+      n foo_: C
+      n foo_:[Any] C
+
+      1 bar_: C
+      1 bar_:[Any] C
+
+      n bar_: C
+      n bar_:[Any] C
     }
   """.trim
 
@@ -21,7 +32,6 @@ object Test extends DirectTest {
 
 class C {
   def foo_:[Dummy](i: => Int): Int = i
-  def t(c: C) = 1 foo_: c
-  def u(c: C) = 1 foo_:[Any] c
+  def bar_:[Dummy](i:    Int): Int = i
 }
 object C extends C