Remove remaining bits from untyped inliner

Author: allanrenucci

compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala

@@ -656,8 +656,7 @@ class TreePickler(pickler: TastyPickler) {
       // Such annotations will be reconstituted when unpickling the child class.
       // See tests/pickling/i3149.scala
     case _ =>
-      if (Inliner.typedInline) ann.symbol == defn.BodyAnnot // inline bodies are reconstituted automatically when unpickling
-      else false
+      ann.symbol == defn.BodyAnnot // inline bodies are reconstituted automatically when unpickling
   }
 
   def pickleAnnotation(owner: Symbol, ann: Annotation)(implicit ctx: Context): Unit =

compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala

@@ -22,7 +22,6 @@ import core.quoted.PickledQuotes
 import scala.quoted
 import scala.quoted.Types.TreeType
 import scala.quoted.Exprs.TastyTreeExpr
-import typer.Inliner.typedInline
 
 import scala.annotation.internal.sharable
 
@@ -555,7 +554,7 @@ class TreeUnpickler(reader: TastyReader,
         sym.completer.withDecls(newScope)
         forkAt(templateStart).indexTemplateParams()(localContext(sym))
       }
-      else if (typedInline && sym.isInlineMethod)
+      else if (sym.isInlineMethod)
         sym.addAnnotation(LazyBodyAnnotation { ctx0 =>
           implicit val ctx: Context = localContext(sym)(ctx0).addMode(Mode.ReadPositions)
             // avoids space leaks by not capturing the current context
@@ -643,14 +642,9 @@ class TreeUnpickler(reader: TastyReader,
         val lazyAnnotTree = readLaterWithOwner(end, rdr => ctx => rdr.readTerm()(ctx))
 
         owner =>
-          if (tp.isRef(defn.BodyAnnot)) {
-            assert(!typedInline)
-            LazyBodyAnnotation(implicit ctx => lazyAnnotTree(owner).complete)
-          }
-          else
-            Annotation.deferredSymAndTree(
-              implicit ctx => tp.typeSymbol,
-              implicit ctx => lazyAnnotTree(owner).complete)
+          Annotation.deferredSymAndTree(
+            implicit ctx => tp.typeSymbol,
+            implicit ctx => lazyAnnotTree(owner).complete)
     }
 
     /** Create symbols for the definitions in the statement sequence between
@@ -749,7 +743,7 @@ class TreeUnpickler(reader: TastyReader,
       def readRhs(implicit ctx: Context) =
         if (nothingButMods(end))
           EmptyTree
-        else if (sym.isInlineMethod && typedInline)
+        else if (sym.isInlineMethod)
           // The body of an inline method is stored in an annotation, so no need to unpickle it again
           new Trees.Lazy[Tree] {
             def complete(implicit ctx: Context) = typer.Inliner.bodyToInline(sym)

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

@@ -25,8 +25,6 @@ import util.Positions.Position
 object Inliner {
   import tpd._
 
-  val typedInline: Boolean = true
-
   /** `sym` is an inline method with a known body to inline (note: definitions coming
    *  from Scala2x class files might be `@forceInline`, but still lack that body).
    */

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

@@ -75,11 +75,7 @@ object ProtoTypes {
      *  achieved by replacing expected type parameters with wildcards.
      */
     def constrainResult(meth: Symbol, mt: Type, pt: Type)(implicit ctx: Context): Boolean =
-      if (Inliner.isInlineable(meth) && !Inliner.typedInline) {
-        constrainResult(mt, wildApprox(pt))
-        true
-      }
-      else constrainResult(mt, pt)
+      constrainResult(mt, pt)
   }
 
   object NoViewsAllowed extends Compatibility {

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

@@ -1992,17 +1992,9 @@ class Typer extends Namer
           case none =>
             typed(mdef) match {
               case mdef1: DefDef if Inliner.hasBodyToInline(mdef1.symbol) =>
-                if (Inliner.typedInline) {
-                  buf += inlineExpansion(mdef1)
-                    // replace body with expansion, because it will be used as inlined body
-                    // from separately compiled files - the original BodyAnnotation is not kept.
-                }
-                else {
-                  assert(mdef1.symbol.isInlineMethod, mdef.symbol)
-                  Inliner.bodyToInline(mdef1.symbol) // just make sure accessors are computed,
-                  buf += mdef1                       // but keep original definition, since inline-expanded code
-                                                     // is pickled in this case.
-                }
+                buf += inlineExpansion(mdef1)
+                  // replace body with expansion, because it will be used as inlined body
+                  // from separately compiled files - the original BodyAnnotation is not kept.
               case mdef1 =>
                 import untpd.modsDeco
                 mdef match {
@@ -2453,8 +2445,7 @@ class Typer extends Namer
                !ctx.settings.YnoInline.value &&
                !ctx.isAfterTyper &&
                !ctx.reporter.hasErrors &&
-               (!Inliner.typedInline || tree.tpe <:< pt)) {
-        if (!Inliner.typedInline) tree.tpe <:< wildApprox(pt)
+               tree.tpe <:< pt) {
         readaptSimplified(Inliner.inlineCall(tree, pt))
       }
       else if (tree.tpe <:< pt) {