Allow abstract inline methods

 - Introduce a new restriction that inline methods can only be
implemented or overridden by other inline methods.

 - Drop the old restriction that inline methods must override
at least one concrete method.

 - Change the rules for retaining inline methods: An inline method
   is retained if it overrides or implements at least one non-inline method.

Author: odersky

compiler/src/dotty/tools/dotc/core/SymDenotations.scala

@@ -938,7 +938,8 @@ object SymDenotations {
     def isInlineMethod(implicit ctx: Context): Boolean =
       isAllOf(InlineMethod, butNot = Accessor)
 
-    def isInlineRetained: Ctx[Boolean] = is(Override)
+    def isInlineRetained: Ctx[Boolean] =
+      allOverriddenSymbols.exists(!_.is(Inline))
 
     /** Is this a Scala 2 macro */
     final def isScala2Macro(implicit ctx: Context): Boolean = is(Macro) && symbol.owner.is(Scala2x)

compiler/src/dotty/tools/dotc/transform/TreeChecker.scala

@@ -80,7 +80,8 @@ class TreeChecker extends Phase with SymTransformer {
     val badDeferredAndPrivate =
       sym.is(Method) && sym.is(Deferred) && sym.is(Private)
       && !sym.hasAnnotation(defn.NativeAnnot)
-      && !sym.is(Erased)
+      && !sym.isEffectivelyErased
+
     assert(!badDeferredAndPrivate, i"$sym is both Deferred and Private")
 
     checkCompanion(symd)

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

@@ -472,7 +472,6 @@ object Checking {
         fail(OnlyClassesCanHaveDeclaredButUndefinedMembers(sym))
       checkWithDeferred(Private)
       checkWithDeferred(Final)
-      checkWithDeferred(Inline)
     }
     if (sym.isValueClass && sym.is(Trait) && !sym.isRefinementClass)
       fail(CannotExtendAnyVal(sym))

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

@@ -157,8 +157,7 @@ object RefChecks {
    *    1.8.3  M is of type ()S, O is of type []T and S <: T, or
    *    1.9.1  If M is erased, O is erased. If O is erased, M is erased or inline.
    *    1.9.2  If M or O are extension methods, they must both be extension methods.
-   *    1.10   If M is an inline or Scala-2 macro method, O cannot be deferred unless
-   *           there's also a concrete method that M overrides.
+   *    1.10   If O is inline, M must be inline
    *    1.11.  If O is a Scala-2 macro, M must be a Scala-2 macro.
    *  2. Check that only abstract classes have deferred members
    *  3. Check that concrete classes do not have deferred definitions
@@ -398,9 +397,8 @@ object RefChecks {
         overrideError("is an extension method, cannot override a normal method")
       else if (other.isAllOf(ExtensionMethod) && !member.isAllOf(ExtensionMethod)) // (1.9.2)
         overrideError("is a normal method, cannot override an extension method")
-      else if ((member.isInlineMethod || member.isScala2Macro) && other.is(Deferred) &&
-                 member.extendedOverriddenSymbols.forall(_.is(Deferred))) // (1.10)
-        overrideError("is an inline method, must override at least one concrete method")
+      else if other.isInlineMethod && !member.isInlineMethod then // (1.10)
+        overrideError("is not inline, cannot override an inline method")
       else if (other.isScala2Macro && !member.isScala2Macro) // (1.11)
         overrideError("cannot be used here - only Scala-2 macros can override Scala-2 macros")
       else if (!compatibleTypes(memberTp(self), otherTp(self)) &&

tests/neg-macros/quote-MacroOverride.scala

@@ -6,8 +6,8 @@ object Test {
   }
 
   object B extends A {
-    override inline def f() = () // error: method f of type (): Unit is an inline method, must override at least one concrete method
-    override def g() = ()
+    override inline def f() = ()
+    override def g() = () // error: is not inline, cannot override an inline method
   }
 
 }

tests/neg/inlinevals.scala

@@ -1,6 +1,6 @@
 object Test {
 
-  def power0(x: Double, inline n: Int): Double = ???  // error
+  def power0(x: Double, inline n: Int): Double = ???  // error: inline modifier can only be used for parameters of inline methods
 
   inline def power(x: Double, inline n: Int): Double = // ok
     inline if n == 0 then ??? else ???
@@ -10,21 +10,21 @@ object Test {
 
   inline inline val twice = 30 // error: repeated modifier
 
-  class C(inline x: Int, private inline val y: Int) { // error // error
-    inline val foo: Int // error: abstract member may not be inline
-    inline def bar: Int // error: abstract member may not be inline
+  class C(inline x: Int, private inline val y: Int) { // error // error inline modifier can only be used for parameters of inline methods (both)
+    inline val foo: Int
+    inline def bar: Int
   }
 
   power(2.0, N) // ok, since it's a by-name parameter
-  power(2.0, X) // error: argument to inline parameter must be a constant expression
+  power(2.0, X) // error: cannot reduce inline if
 
   inline val M = X  // error: rhs must be constant expression
 
   inline val xs = List(1, 2, 3) // error: must be a constant expression
 
   inline def foo(x: Int) = {
 
-    def f(inline xs: List[Int]) = xs // error
+    def f(inline xs: List[Int]) = xs // error: inline modifier can only be used for parameters of inline methods
 
     inline val y = { println("hi"); 1 }  // ok
     inline val z = x // ok

tests/neg/transparent-override/B_2.scala

@@ -1,9 +1,9 @@
 class B extends A {
-  inline def f(x: Int): Int = inline x match { // error
+  inline def f(x: Int): Int = inline x match { // OK
     case 0 => 1
     case _ => x
   }
-  def g(x: Int): Int = 1  // error
+  override def g(x: Int): Int = 1 // error: is not inline, cannot override an inline methiod
 }
 
 

tests/run/inline-override.check

@@ -1,2 +1,5 @@
 inline 22
 inline 22
+inline 22
+inline 22
+inline 22

tests/run/inline-override.scala

@@ -1,13 +1,23 @@
-class A:
+abstract class A:
   def f(x: Int) = s"dynamic $x"
+  def h(x: Int): String
+  inline def i(x: Int): String
 
 class B extends A:
   inline override def f(x: Int) = g(x)
   inline def g(x: Int) = s"inline $x"
+  inline def h(x: Int) = g(x)
+  inline def i(x: Int) = g(x)
 
 @main def Test =
   val b = B()
   println(b.f(22))
+  println(b.h(22))
+  println(b.i(22))
   val a: A = b
   println(a.f(22))
+  println(a.h(22))
+//  println(a.i(22))
+
+
 

tests/run/quote-MacroOverride.scala

@@ -7,7 +7,7 @@ object Test {
   }
 
   object B extends A {
-    override def f1(): String = "B.f1"
+    override inline def f1(): String = "B.f1"
     override inline def f2(): String = "B.f2"
     override inline def f3(): String = "B.f3"
   }