Address review suggestions

Author: odersky

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

@@ -519,6 +519,7 @@ object Flags {
   val AbstractSealed: FlagSet                = Abstract | Sealed
   val AbstractOrTrait: FlagSet               = Abstract | Trait
   val EffectivelyOpenFlags                   = Abstract | JavaDefined | Open | Scala2x | Trait
+  val AccessorOrDeferred: FlagSet            = Accessor | Deferred
   val PrivateAccessor: FlagSet               = Accessor | Private
   val AccessorOrSynthetic: FlagSet           = Accessor | Synthetic
   val EnumCase: FlagSet                      = Case | Enum

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

@@ -938,16 +938,17 @@ object SymDenotations {
     def isInlineMethod(implicit ctx: Context): Boolean =
       isAllOf(InlineMethod, butNot = Accessor)
 
-    def isInlineRetained(using Context): Boolean =
-      !is(Deferred) && allOverriddenSymbols.exists(!_.is(Inline))
+    def isRetainedInlineMethod(using Context): Boolean =
+      isAllOf(InlineMethod, butNot = AccessorOrDeferred)
+      && allOverriddenSymbols.exists(!_.is(Inline))
 
     /** Is this a Scala 2 macro */
     final def isScala2Macro(implicit ctx: Context): Boolean = is(Macro) && symbol.owner.is(Scala2x)
 
     /** An erased value or an inline method.
      */
     def isEffectivelyErased(implicit ctx: Context): Boolean =
-      is(Erased) || isInlineMethod && !isInlineRetained
+      is(Erased) || isInlineMethod && !isRetainedInlineMethod
 
     /** ()T and => T types should be treated as equivalent for this symbol.
      *  Note: For the moment, we treat Scala-2 compiled symbols as loose matching,

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

@@ -85,7 +85,7 @@ class Erasure extends Phase with DenotTransformer {
           else oldFlags &~ Flags.HasDefaultParamsFlags // HasDefaultParamsFlags needs to be dropped because overriding might become overloading
         val oldAnnotations = ref.annotations
         var newAnnotations = oldAnnotations
-        if oldSymbol.isInlineMethod && oldSymbol.isInlineRetained then
+        if oldSymbol.isRetainedInlineMethod then
           newFlags = newFlags &~ Flags.Inline
           newAnnotations = newAnnotations.filterConserve(!_.isInstanceOf[BodyAnnotation])
         // TODO: define derivedSymDenotation?
@@ -922,7 +922,7 @@ object Erasure {
           (inlineMeth, stat)
       }.toMap
       stats.mapConserve {
-        case stat: DefDef if stat.symbol.isInlineMethod && stat.symbol.isInlineRetained =>
+        case stat: DefDef if stat.symbol.isRetainedInlineMethod =>
           val rdef = retainerDef(stat.symbol)
           val fromParams = untpd.allParamSyms(rdef)
           val toParams = untpd.allParamSyms(stat)

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

@@ -2421,7 +2421,7 @@ class Typer extends Namer
    */
   protected def inlineExpansion(mdef: DefDef)(implicit ctx: Context): List[Tree] =
     tpd.cpy.DefDef(mdef)(rhs = Inliner.bodyToInline(mdef.symbol))
-    :: (if mdef.symbol.isInlineRetained then Inliner.bodyRetainer(mdef) :: Nil else Nil)
+    :: (if mdef.symbol.isRetainedInlineMethod then Inliner.bodyRetainer(mdef) :: Nil else Nil)
 
   def typedExpr(tree: untpd.Tree, pt: Type = WildcardType)(implicit ctx: Context): Tree =
     typed(tree, pt)(ctx retractMode Mode.PatternOrTypeBits)

docs/docs/reference/metaprogramming/inline.md

@@ -177,8 +177,9 @@ abstract class A {
 object B extends A {
   inline def f(): Int = 22
 }
-B.f()  // OK
-val a: A = B; a.f() // error: cannot inline f() in A.
+B.f()         // OK
+val a: A = B
+a.f()         // error: cannot inline f() in A.
 ```
 
 ### Relationship to @inline