Disallow invocations of deferred inline methods

Author: odersky

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

@@ -125,14 +125,26 @@ object Inliner {
   }
 
   /** For a retained inline method: The inline expansion of the call to itself with its
-   *  parameters as arguments.
+   *  parameters as arguments. Given an inline method
+   *
+   *    inline def f[Ts](xs: Us) = body
+   *
+   *  This sets up the call
+   *
+   *    f[Ts'](xs')
+   *
+   *  where the 'ed parameters are copies of the original ones. The call is
+   *  then inline processed in a context which has a clone f' of f as owner.
+   *  The cloning of owner and parameters is necessary since otherwise the
+   *  inliner gets confused in various ways. The inlined body is then
+   *  transformed back by replacing cloned versions of parameters with original
+   *  and replacing the cloned owner f' with f.
    */
   def inlineSelfCall(mdef: DefDef)(using ctx: Context): Tree =
     val meth = mdef.symbol
     val origParams: List[Symbol] = mdef.tparams.map(_.symbol) ::: mdef.vparamss.flatten.map(_.symbol)
     val callParams: List[Symbol] = origParams.map(_.copy())
     val callOwner = meth.copy(flags = meth.flags &~ Inline)
-    assert(ctx.owner != meth)
     inlineCall(
       ref(meth)
         .appliedToTypes(mdef.tparams.tpes)

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

@@ -2939,9 +2939,13 @@ class Typer extends Namer
                !suppressInline) {
         tree.tpe <:< wildApprox(pt)
         val errorCount = ctx.reporter.errorCount
-        val inlined = Inliner.inlineCall(tree)
-        if ((inlined ne tree) && errorCount == ctx.reporter.errorCount) readaptSimplified(inlined)
-        else inlined
+        val meth = methPart(tree).symbol
+        if meth.is(Deferred) then
+          errorTree(tree, i"Deferred inline ${meth.showLocated} cannot be invoked")
+        else
+          val inlined = Inliner.inlineCall(tree)
+          if ((inlined ne tree) && errorCount == ctx.reporter.errorCount) readaptSimplified(inlined)
+          else inlined
       }
       else if (tree.symbol.isScala2Macro &&
                // raw and s are eliminated by the StringInterpolatorOpt phase

tests/neg/inline-abstract.scala

@@ -0,0 +1,11 @@
+class A:
+  inline def f(): Int
+
+class B extends A:
+  inline def f() = 1
+
+def Test =
+  val b = B()
+  println(b.f())  // ok
+  val a: A = b
+  println(a.f())  // error: Deferred inline method f in class A cannot be invoked