Review

Author: nicolasstucki

compiler/src/dotty/tools/dotc/config/ScalaSettings.scala

@@ -227,7 +227,7 @@ class ScalaSettings extends Settings.SettingGroup with CommonScalaSettings {
   val Yinstrument: Setting[Boolean] = BooleanSetting("-Yinstrument", "Add instrumentation code that counts allocations and closure creations.")
   val YinstrumentDefs: Setting[Boolean] = BooleanSetting("-Yinstrument-defs", "Add instrumentation code that counts method calls; needs -Yinstrument to be set, too.")
 
-  val YforceInlineWhileTyping: Setting[Boolean] = BooleanSetting("-Yforce-inline-while-typing", "")
+  val YforceInlineWhileTyping: Setting[Boolean] = BooleanSetting("-Yforce-inline-while-typing", "Make non-transparent inline methods inline when typing. Emulates the old inlining behavior of 3.0.0-M3.")
 
   /** Dottydoc specific settings that are not used in scaladoc */
   val docSnapshot: Setting[Boolean] = BooleanSetting("-doc-snapshot", "Generate a documentation snapshot for the current Dotty version")

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

@@ -106,7 +106,7 @@ class Inlining extends MacroTransform {
 object Inlining {
   val name: String = "inlining"
 
-  /** Check that `vdef.rhs` can be right hand-side or argument to `inline` value or parameter. */
+  /** Check that `vdef.rhs` can be right hand-side of an `inline` value definition. */
   def checkInlineConformant(vdef: tpd.ValDef)(using Context): Unit = {
     val ValDef(_, tpt, rhs) = vdef
     if vdef.symbol.is(Inline, butNot = DeferredOrTermParamOrAccessor) && !ctx.erasedTypes && !Inliner.inInlineMethod then

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

@@ -258,7 +258,7 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer { thisPhase
     override def transform(tree: Tree)(using Context): Tree =
       try tree match {
         case tree: Ident if !tree.isType =>
-          if tree.symbol.is(Inline) then
+          if tree.symbol.is(Inline) && !Inliner.inInlineMethod then
             ctx.compilationUnit.needsInlining = true
           checkNoConstructorProxy(tree)
           tree.tpe match {
@@ -276,7 +276,7 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer { thisPhase
             checkNoConstructorProxy(tree)
             transformSelect(tree, Nil)
         case tree: Apply =>
-          if tree.symbol.is(Inline) then
+          if tree.symbol.is(Inline) && !Inliner.inInlineMethod then
             ctx.compilationUnit.needsInlining = true
           val methType = tree.fun.tpe.widen
           val app =

docs/docs/reference/metaprogramming/inline.md

@@ -285,10 +285,11 @@ val one: 1 = zero + 1
 ```
 
 ### Transparent vs. non-transparent inline
-As we already discussed, transparent inline methods will provide a more precise.
-Technically this implies that transparent inline methods must be expanded while typing the program. Other inline methods are inlined later after the program is fully typed.
+As we already discussed, transparent inline methods may influence type checking at call site.
+Technically this implies that transparent inline methods must be expanded during type checking of the program.
+Other inline methods are inlined later after the program is fully typed.
 
-For example the following two functions will be typed the same way but will be inlined at different times.
+For example, the following two functions will be typed the same way but will be inlined at different times.
 ```scala
 inline def f1: T = ...
 transparent inline def f2: T = (...): T
@@ -297,7 +298,8 @@ transparent inline def f2: T = (...): T
 A noteworthy difference is the behavior of `transparent inline given`.
 If there is an error reported when inlining that definition, it will be considered as an implicit search mismatch and the search will continue.
 A `transparent inline given` can add a type ascription in its RHS (as in `f2` from the previous example) to avoid the precise type but keep the search behavior.
-On the other hand `inline given` be taken as the implicit and then after typing is done the code is inlined and any error will be emitted as usual.
+On the other hand, `inline given` be taken as the implicit and then inlined after typing.
+Any error will be emitted as usual.
 
 ## Inline Conditionals
 
@@ -328,7 +330,7 @@ below:
    | This location is in code that was inlined at ...
 ```
 
-In a transparent inline, an `inline if` will force the inlining of any inline definition in its condition.
+In a transparent inline, an `inline if` will force the inlining of any inline definition in its condition during type checking.
 
 ## Inline Matches