Type ascribe arguments of bottom type to inline functions

Fixes scala#11225
Fixes scala#11864

Author: odersky

compiler/src/dotty/tools/dotc/typer/Inliner.scala

@@ -452,24 +452,28 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(using Context) {
    */
   private def paramBindingDef(name: Name, paramtp: Type, arg0: Tree,
                               bindingsBuf: mutable.ListBuffer[ValOrDefDef])(using Context): ValOrDefDef = {
+    val isByName = paramtp.dealias.isInstanceOf[ExprType]
     val arg = arg0 match {
       case Typed(arg1, tpt) if tpt.tpe.isRepeatedParam && arg1.tpe.derivesFrom(defn.ArrayClass) =>
         wrapArray(arg1, arg0.tpe.elemType)
       case _ => arg0
     }
     val argtpe = arg.tpe.dealiasKeepAnnots.translateFromRepeated(toArray = false)
-    val isByName = paramtp.dealias.isInstanceOf[ExprType]
-    var inlineFlags: FlagSet = InlineProxy
-    if (paramtp.widenExpr.hasAnnotation(defn.InlineParamAnnot)) inlineFlags |= Inline
-    if (isByName) inlineFlags |= Method
-    val (bindingFlags, bindingType) =
-      if (isByName) (inlineFlags, ExprType(argtpe.widen))
-      else (inlineFlags, argtpe.widen)
+    val argIsBottom = argtpe.isBottomTypeAfterErasure
+    val bindingType =
+      if argIsBottom then paramtp.dealias
+      else if isByName then ExprType(argtpe.widen)
+      else argtpe
+    var bindingFlags: FlagSet = InlineProxy
+    if paramtp.widenExpr.hasAnnotation(defn.InlineParamAnnot) && !argIsBottom then
+      bindingFlags |= Inline  // Don't inline arguments of type Nothing or Null; they need to be type ascribed
+                              // to avoid type errors in the inlined code. See i8612.scala
+    if isByName then
+      bindingFlags |= Method
     val boundSym = newSym(InlineBinderName.fresh(name.asTermName), bindingFlags, bindingType).asTerm
     val binding = {
       val newArg = arg.changeOwner(ctx.owner, boundSym)
-      if (isByName) DefDef(boundSym, newArg)
-      else ValDef(boundSym, newArg)
+      if isByName then DefDef(boundSym, newArg) else ValDef(boundSym, newArg)
     }.withSpan(boundSym.span)
     bindingsBuf += binding
     binding
@@ -479,30 +483,35 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(using Context) {
    *  corresponding arguments. `bindingbuf` will be further extended later by
    *  proxies to this-references. Issue an error if some arguments are missing.
    */
-  private def computeParamBindings(tp: Type, targs: List[Tree], argss: List[List[Tree]]): Boolean = tp match
-    case tp: PolyType =>
-      tp.paramNames.lazyZip(targs).foreach { (name, arg) =>
-        paramSpan(name) = arg.span
-        paramBinding(name) = arg.tpe.stripTypeVar
-      }
-      computeParamBindings(tp.resultType, targs.drop(tp.paramNames.length), argss)
-    case tp: MethodType =>
-      if argss.isEmpty then
-        report.error(i"missing arguments for inline method $inlinedMethod", call.srcPos)
-        false
-      else
-        tp.paramNames.lazyZip(tp.paramInfos).lazyZip(argss.head).foreach { (name, paramtp, arg) =>
+  private def computeParamBindings(
+      tp: Type, targs: List[Tree], argss: List[List[Tree]], paramSubst: Type => Type): Boolean =
+    tp match
+      case tp: PolyType =>
+        tp.paramNames.lazyZip(targs).foreach { (name, arg) =>
           paramSpan(name) = arg.span
-          paramBinding(name) = arg.tpe.dealias match {
-            case _: SingletonType if isIdempotentPath(arg) => arg.tpe
-            case _ => paramBindingDef(name, paramtp, arg, bindingsBuf).symbol.termRef
-          }
+          paramBinding(name) = arg.tpe.stripTypeVar
         }
-        computeParamBindings(tp.resultType, targs, argss.tail)
-    case _ =>
-      assert(targs.isEmpty)
-      assert(argss.isEmpty)
-      true
+        computeParamBindings(
+          tp.resultType, targs.drop(tp.paramNames.length), argss,
+          paramSubst.andThen(_.substParams(tp, targs.map(_.tpe.stripTypeVar))))
+      case tp: MethodType =>
+        if argss.isEmpty then
+          report.error(i"missing arguments for inline method $inlinedMethod", call.srcPos)
+          false
+        else
+          tp.paramNames.lazyZip(tp.paramInfos).lazyZip(argss.head).foreach { (name, paramtp, arg) =>
+            paramSpan(name) = arg.span
+            paramBinding(name) = arg.tpe.dealias match
+              case _: SingletonType if isIdempotentPath(arg) =>
+                arg.tpe
+              case _ =>
+                paramBindingDef(name, paramSubst(paramtp), arg, bindingsBuf).symbol.termRef
+          }
+          computeParamBindings(tp.resultType, targs, argss.tail, paramSubst)
+      case _ =>
+        assert(targs.isEmpty)
+        assert(argss.isEmpty)
+        true
 
   // Compute val-definitions for all this-proxies and append them to `bindingsBuf`
   private def computeThisBindings() = {
@@ -687,7 +696,7 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(using Context) {
       }
 
     // Compute bindings for all parameters, appending them to bindingsBuf
-    if !computeParamBindings(inlinedMethod.info, callTypeArgs, callValueArgss) then
+    if !computeParamBindings(inlinedMethod.info, callTypeArgs, callValueArgss, identity) then
       return call
 
     // make sure prefix is executed if it is impure

tests/neg/i11225.scala

@@ -25,6 +25,6 @@ class Test:
   transparent inline def uni = uninitialized
 
   inline def g(inline x: Int): Unit = ()
-  def f2 = g(uninitialized) // this one is ok since `uninitialized` is inlined away
+  def f2 = g(uninitialized) // error
 
   var x7: Int = uni  // error

tests/pos/i11864.scala

@@ -0,0 +1,35 @@
+import language.experimental.erasedDefinitions
+
+type Ev = { type Out }
+type Sub[X] = Ev { type Out = X }
+
+object test1:
+  transparent inline def foo(ev: Ev): Option[ev.Out] = ???
+  transparent inline def bar[X](ev: Sub[X]): Option[ev.Out] = ???
+  def test =
+    foo(???)
+    val y = bar[Int](???)
+    y: Option[Int]
+
+object test2:
+  inline def foo(ev: Ev): Option[ev.Out] = ???
+  inline def bar[X](ev: Sub[X]): Option[ev.Out] = ???
+  def test =
+    foo(???)
+    val y = bar[Int](???)
+    y: Option[Int]
+
+final class CallbackTo[+A] {
+  inline def map[B](f: A => B)(using erased ev: CallbackTo.MapGuard[B]): CallbackTo[ev.Out] = ???
+}
+
+object CallbackTo {
+
+  type MapGuard[A] = { type Out = A }
+  erased given MapGuard[A]: MapGuard[A] = ???
+
+  def traverse[A, B](ta: List[A]): CallbackTo[List[B]] =
+    val x: CallbackTo[List[A] => List[B]] = ???
+    x.map(_(ta))
+}
+

tests/pos/i8612.scala

@@ -0,0 +1,17 @@
+object Foo1:
+  def assert1(x: Boolean) = if !x then ???
+  inline def assert2(x: Boolean) = if !x then ???
+  inline def assert3(inline x: Boolean) = if !x then ???
+
+  assert1(???)
+  assert2(???)
+  assert3(???)
+
+object Foo2:
+  def assert1(x: Boolean) = if !x then ???
+  transparent inline def assert2(x: Boolean) = if !x then ???
+  transparent inline def assert3(inline x: Boolean) = if !x then ???
+
+  assert1(???)
+  assert2(???)
+  assert3(???)