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)
+ }
+}