Handle by-name parameters properly

Author: liufengyun

compiler/src/dotty/tools/dotc/transform/init/Errors.scala

@@ -60,7 +60,7 @@ object Errors {
   case class AccessNonInit(field: Symbol, trace: Vector[Tree]) extends Error {
     def source: Tree = trace.last
     def show(implicit ctx: Context): String =
-      "Access non-initialized field " + field.show + "."
+      "Access non-initialized field " + field.name.show + "."
 
     override def report(implicit ctx: Context): Unit = ctx.error(show + stacktrace, field.sourcePos)
   }

compiler/src/dotty/tools/dotc/transform/init/Summarization.scala

@@ -70,9 +70,13 @@ object Summarization {
         val summary = analyze(fun)
         val ignoredCall = env.ignoredMethods.contains(expr.symbol)
 
-        val res = args.foldLeft(summary) { (sum, arg) =>
+        val argTps = fun.tpe.widen match
+          case mt: MethodType => mt.paramInfos
+
+        val res = args.zip(argTps).foldLeft(summary) { case (sum, (arg, argTp)) =>
           val (pots1, effs1) = analyze(arg)
           if (ignoredCall) sum.withEffs(effs1)
+          else if (argTp.isInstanceOf[ExprType]) sum + Promote(Fun(pots1, effs1)(arg))(arg)
           else sum.withEffs(pots1.promote(arg) ++ effs1)
         }
 

tests/init/neg/lazylist1.scala

@@ -2,7 +2,7 @@ class LazyList[A]
 
 object LazyList {
   inline implicit def toDeferred[A](l: LazyList[A]): Deferred[A] =
-    new Deferred(l)
+    new Deferred(l)  // error
 
   final class Deferred[A](l: => LazyList[A]) {
     def #:: [B >: A](elem: => B): LazyList[B] = ???
@@ -16,5 +16,5 @@ final class Test {
   lazy val b: LazyList[Int] = 10 #:: a
 
   val x: LazyList[Int] = 5 #:: y
-  val y: LazyList[Int] = 10 #:: x  // error
+  val y: LazyList[Int] = 10 #:: x
 }

tests/init/neg/lazylist2.scala

@@ -26,8 +26,8 @@ final class Test1 {
   a.head // ok
   b.head // ok
 
-  val x: LazyList[Int] = 5 #:: y
-  val y: LazyList[Int] = 10 #:: x   // error
+  val x: LazyList[Int] = 5 #:: y   // error
+  val y: LazyList[Int] = 10 #:: x
 }
 
 final class Test2 {
@@ -37,7 +37,7 @@ final class Test2 {
 }
 
 final class Test3 {
-  val a: LazyList[Int] = n #:: (a: @unchecked)
+  val a: LazyList[Int] = n #:: (a: @unchecked)    // error
   a.head
-  val n: Int = 20    // error
+  val n: Int = 20
 }

tests/init/neg/t3273.check

@@ -0,0 +1,22 @@
+-- Error: tests/init/neg/t3273.scala:4:42 ------------------------------------------------------------------------------
+4 |  val num1: LazyList[Int] = 1 #:: num1.map(_ + 1)                        // error
+  |                                  ^^^^^^^^^^^^^^^
+  |             Promoting the value to fully-initialized is unsafe.
+  |              Calling trace:
+  |              -> val num1: LazyList[Int] = 1 #:: num1.map(_ + 1)                        // error	[ t3273.scala:4 ]
+  |
+  |             The unsafe promotion may cause the following problem(s):
+  |
+  |             1. Access non-initialized field num1. Calling trace:
+  |              -> val num1: LazyList[Int] = 1 #:: num1.map(_ + 1)                        // error	[ t3273.scala:4 ]
+-- Error: tests/init/neg/t3273.scala:5:61 ------------------------------------------------------------------------------
+5 |  val num2: LazyList[Int] = 1 #:: num2.iterator.map(_ + 1).to(LazyList)  // error
+  |                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  |             Promoting the value to fully-initialized is unsafe.
+  |              Calling trace:
+  |              -> val num2: LazyList[Int] = 1 #:: num2.iterator.map(_ + 1).to(LazyList)  // error	[ t3273.scala:5 ]
+  |
+  |             The unsafe promotion may cause the following problem(s):
+  |
+  |             1. Access non-initialized field num2. Calling trace:
+  |              -> val num2: LazyList[Int] = 1 #:: num2.iterator.map(_ + 1).to(LazyList)  // error	[ t3273.scala:5 ]

tests/init/neg/t3273.scala

@@ -0,0 +1,12 @@
+import scala.language.implicitConversions
+
+object Test {
+  val num1: LazyList[Int] = 1 #:: num1.map(_ + 1)                        // error
+  val num2: LazyList[Int] = 1 #:: num2.iterator.map(_ + 1).to(LazyList)  // error
+
+  def main(args: Array[String]): Unit = {
+    val x1 = (num1 take 10).toList
+    val x2 = (num2 take 10).toList
+    assert(x1 == x2)
+  }
+}