Use effectivelyFinal for inline methods

Author: nicolasstucki

compiler/src/dotty/tools/dotc/ast/Desugar.scala

@@ -251,8 +251,6 @@ object desugar {
       cpy.DefDef(meth)(name = methName, tparams = tparams1), epbuf.toList)
 
     if (meth1.mods.is(Inline))
-      if !meth1.rhs.isEmpty then
-        meth1 = meth1.withMods(meth1.mods | Final)
       meth1.tpt match {
         case TypeBoundsTree(_, tpt1, _) =>
           meth1 = cpy.DefDef(meth1)(tpt = tpt1)

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

@@ -1097,7 +1097,9 @@ object SymDenotations {
 
     /** A symbol is effectively final if it cannot be overridden in a subclass */
     final def isEffectivelyFinal(implicit ctx: Context): Boolean =
-      isOneOf(EffectivelyFinalFlags) || !owner.isExtensibleClass
+      isOneOf(EffectivelyFinalFlags)
+      || is(Inline, butNot = Deferred)
+      || !owner.isExtensibleClass
 
     /** A class is effectively sealed if has the `final` or `sealed` modifier, or it
      *  is defined in Scala 3 and is neither abstract nor open.

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

@@ -157,7 +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.1. If O is inline, M must be inline
+   *    1.10.1.   If O is inline (and deferred, otherwise O would be final), M must be inline
    *    1.10.2. If M is inline, M must not be deferred
    *    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
@@ -399,7 +399,7 @@ object RefChecks {
       else if (other.isAllOf(ExtensionMethod) && !member.isAllOf(ExtensionMethod)) // (1.9.2)
         overrideError("is a normal method, cannot override an extension method")
       else if other.isInlineMethod && !member.isInlineMethod then // (1.10.1)
-        overrideError("is not inline, cannot override an inline method")
+        overrideError("is not inline, cannot implement an inline method")
       else if member.isInlineMethod && member.is(Deferred) then // (1.10.2)
         overrideError("is inline method, cannot be an abstract override")
       else if (other.isScala2Macro && !member.isScala2Macro) // (1.11)

docs/docs/reference/metaprogramming/inline.md

@@ -167,7 +167,7 @@ assert(a.g() == 33)
 ```
 The inlined invocations and the dynamically dispatched invocations give the same results.
 
-2. Inline methods are final.
+2. Inline methods are effectively final.
 
 3. Inline methods can also be abstract. An abstract inline method can be implemented only by other inline methods. It cannot be invoked directly:
 ```scala