Proper laziness for by-name args of right-associative operators

This fixes scala/bug#1980 by changing the
desugaring of right-associative operator syntax in the spec such that
by-name operands now get the same desugaring as left-associative
operators (except for the reversed operands, of course). Only by-value
operands are pulled out into intermediate vals to preserve their
left-to-right evaluation order.

The implementation is as follows:

- `Parsers` still performs the `val` desugaring for all calls, except
  that the generated synthetic names use the new `RIGHT_ASSOC_OP_PREFIX`
  to identify them later.

- When the operator method application is checked in `Typers`, the
  synthetic val’s `Symbol` is marked as `LAZY` if the parameter is
  by-name.

- The `ValDef` of the marked `Symbol` is eliminated in `RefChecks` and
  its RHS inlined at the call site.

This is rather hackish and there is no particular reason for doing it
in `Typers` and `RefChecks` other than the desire to do it early and
without the overhead of extra tree transforms.

Author: szeiger

spec/06-expressions.md

@@ -698,9 +698,9 @@ This expression is then interpreted as $e.\mathit{op}(e_1,\ldots,e_n)$.
 
 A left-associative binary
 operation $e_1;\mathit{op};e_2$ is interpreted as $e_1.\mathit{op}(e_2)$. If $\mathit{op}$ is
-right-associative, the same operation is interpreted as
-`{ val $x$=$e_1$; $e_2$.$\mathit{op}$($x\,$) }`, where $x$ is a fresh
-name.
+right-associative and its parameter is passed by name, the same operation is interpreted as
+$e_2.\mathit{op}(e_1)$. If $\mathit{op}$ is right-associative and its parameter is passed by value,
+it is interpreted as `{ val $x$=$e_1$; $e_2$.$\mathit{op}$($x\,$) }`, where $x$ is a fresh name.
 
 ### Assignment Operators
 

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

@@ -835,7 +835,7 @@ self =>
         if (treeInfo.isLeftAssoc(op)) {
           Apply(mkSelection(left), arguments)
         } else {
-          val x = freshTermName()
+          val x = freshTermName(nme.RIGHT_ASSOC_OP_PREFIX)
           Block(
             List(ValDef(Modifiers(symtab.Flags.SYNTHETIC | symtab.Flags.ARTIFACT), x, TypeTree(), stripParens(left))),
             Apply(mkSelection(right), List(Ident(x))))

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

@@ -9,7 +9,7 @@ package typechecker
 import scala.language.postfixOps
 
 import scala.collection.mutable
-import scala.collection.mutable.ListBuffer
+import scala.collection.mutable.{ListBuffer, HashMap}
 import scala.tools.nsc.settings.ScalaVersion
 import scala.tools.nsc.settings.NoScalaVersion
 
@@ -36,6 +36,7 @@ import transform.Transform
  *   <li>Local modules are replaced by variables and classes</li>
  *   <li>Calls to case factory methods are replaced by new's.</li>
  *   <li>Eliminate branches in a conditional if the condition is a constant</li>
+  *  <li>Synthetic vals from the desugaring of right-associative operators are inlined if they are passed by name<li>
  *  </ul>
  *
  *  @author  Martin Odersky
@@ -116,6 +117,9 @@ abstract class RefChecks extends Transform {
 
     var checkedCombinations = Set[List[Type]]()
 
+    // RHS of ValDefs for by-name RIGHT_ASSOC_OP_PREFIX calls that were eliminated. Subsequent calls are inlined.
+    val eliminatedRightAssocValDefs = new HashMap[Symbol, Tree]
+
     // only one overloaded alternative is allowed to define default arguments
     private def checkOverloadedRestrictions(clazz: Symbol, defaultClass: Symbol): Unit = {
       // Using the default getters (such as methodName$default$1) as a cheap way of
@@ -1703,7 +1707,7 @@ abstract class RefChecks extends Transform {
               assert(sym != NoSymbol, "transformCaseApply: name = " + name.debugString + " tree = " + tree + " / " + tree.getClass) //debug
               enterReference(tree.pos, sym)
             }
-            tree
+            eliminatedRightAssocValDefs.getOrElse(tree.symbol, tree)
 
           case x @ Select(_, _) =>
             transformSelect(x)
@@ -1714,6 +1718,9 @@ abstract class RefChecks extends Transform {
                            // probably not, until we allow parameterised extractors
             tree
 
+          case Block((vd: ValDef) :: Nil, expr) if vd.symbol.isLazy && vd.name.toString.startsWith(nme.RIGHT_ASSOC_OP_PREFIX) =>
+            eliminatedRightAssocValDefs += ((vd.symbol, vd.rhs))
+            transform(expr)
 
           case _ => tree
         }

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

@@ -3591,6 +3591,17 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper
                   case _ => tp
                 }
 
+                // When a RIGHT_ASSOC_OP_PREFIX Ident is passed by name, set its Symbol's LAZY flag.
+                // The RHS then gets inlined and the ValDef removed in refchecks.
+                args1 match {
+                  case (ident @ Ident(name)) :: Nil if name.toString.startsWith(nme.RIGHT_ASSOC_OP_PREFIX) =>
+                    mt.params match {
+                      case param :: Nil if param.isByNameParam => ident.symbol.setFlag(symtab.Flags.LAZY)
+                      case _ =>
+                    }
+                  case _ =>
+                }
+
                 /*
                  * This is translating uses of List() into Nil.  This is less
                  *  than ideal from a consistency standpoint, but it shouldn't be

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

@@ -333,6 +333,7 @@ trait StdNames {
     val FRESH_SUFFIX                   = "macro$" // uses a keyword to avoid collisions with mangled names
     val QUAL_PREFIX                    = "qual$"
     val NAMEDARG_PREFIX                = "x$"
+    val RIGHT_ASSOC_OP_PREFIX          = "rassoc$"
 
     // Compiler internal names
     val ANYname: NameType                  = "<anyname>"

test/files/run/t1980.check

@@ -0,0 +1,8 @@
+defining
+foo 1
+foo 2
+foo 3
+forcing
+bar 1
+bar 2
+bar 3

test/files/run/t1980.scala

@@ -0,0 +1,22 @@
+class LazyList[+A](expr: => LazyList.Evaluated[A]) {
+  def #:: [B >: A](elem: => B): LazyList[B] = new LazyList(Some((elem, this)))
+  def ##:: [B >: A](elem: B): LazyList[B] = new LazyList(Some((elem, this)))
+  def force: Unit = expr.foreach(_._2.force)
+}
+
+object LazyList {
+  type Evaluated[+A] = Option[(A, LazyList[A])]
+  object Empty extends LazyList[Nothing](None)
+  def empty[A]: LazyList[A] = Empty
+}
+
+object Test extends App {
+  def foo(i: Int) = { println("foo "+i); i }
+  def bar(i: Int) = { println("bar "+i); i }
+  println("defining")
+  val xs1 = foo(1) ##:: foo(2) ##:: foo(3) ##:: LazyList.empty
+  val xs2 = bar(1) #:: bar(2) #:: bar(3) #:: LazyList.empty
+  println("forcing")
+  xs1.force
+  xs2.force
+}