Drop InlineIf and InlineMatch

Author: odersky

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

@@ -497,10 +497,6 @@ object Trees {
     extends TermTree[T] {
     type ThisTree[-T >: Untyped] = If[T]
   }
-  class InlineIf[T >: Untyped] private[ast] (cond: Tree[T], thenp: Tree[T], elsep: Tree[T])
-    extends If(cond, thenp, elsep) {
-    override def toString = s"InlineIf($cond, $thenp, $elsep)"
-  }
 
   /** A closure with an environment and a reference to a method.
    *  @param env    The captured parameters of the closure
@@ -521,10 +517,6 @@ object Trees {
     extends TermTree[T] {
     type ThisTree[-T >: Untyped] = Match[T]
   }
-  class InlineMatch[T >: Untyped] private[ast] (selector: Tree[T], cases: List[CaseDef[T]])
-    extends Match(selector, cases) {
-    override def toString = s"InlineMatch($selector, $cases)"
-  }
 
   /** case pat if guard => body; only appears as child of a Match */
   case class CaseDef[-T >: Untyped] private[ast] (pat: Tree[T], guard: Tree[T], body: Tree[T])
@@ -910,10 +902,8 @@ object Trees {
     type Assign = Trees.Assign[T]
     type Block = Trees.Block[T]
     type If = Trees.If[T]
-    type InlineIf = Trees.InlineIf[T]
     type Closure = Trees.Closure[T]
     type Match = Trees.Match[T]
-    type InlineMatch = Trees.InlineMatch[T]
     type CaseDef = Trees.CaseDef[T]
     type Labeled = Trees.Labeled[T]
     type Return = Trees.Return[T]
@@ -1045,9 +1035,6 @@ object Trees {
         case _ => finalize(tree, untpd.Block(stats, expr))
       }
       def If(tree: Tree)(cond: Tree, thenp: Tree, elsep: Tree)(implicit ctx: Context): If = tree match {
-        case tree: InlineIf =>
-          if ((cond eq tree.cond) && (thenp eq tree.thenp) && (elsep eq tree.elsep)) tree
-          else finalize(tree, untpd.InlineIf(cond, thenp, elsep))
         case tree: If if (cond eq tree.cond) && (thenp eq tree.thenp) && (elsep eq tree.elsep) => tree
         case _ => finalize(tree, untpd.If(cond, thenp, elsep))
       }
@@ -1056,9 +1043,6 @@ object Trees {
         case _ => finalize(tree, untpd.Closure(env, meth, tpt))
       }
       def Match(tree: Tree)(selector: Tree, cases: List[CaseDef])(implicit ctx: Context): Match = tree match {
-        case tree: InlineMatch =>
-          if ((selector eq tree.selector) && (cases eq tree.cases)) tree
-          else finalize(tree, untpd.InlineMatch(selector, cases))
         case tree: Match if (selector eq tree.selector) && (cases eq tree.cases) => tree
         case _ => finalize(tree, untpd.Match(selector, cases))
       }

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

@@ -272,10 +272,8 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
   def Assign(lhs: Tree, rhs: Tree): Assign = new Assign(lhs, rhs)
   def Block(stats: List[Tree], expr: Tree): Block = new Block(stats, expr)
   def If(cond: Tree, thenp: Tree, elsep: Tree): If = new If(cond, thenp, elsep)
-  def InlineIf(cond: Tree, thenp: Tree, elsep: Tree): If = new InlineIf(cond, thenp, elsep)
   def Closure(env: List[Tree], meth: Tree, tpt: Tree): Closure = new Closure(env, meth, tpt)
   def Match(selector: Tree, cases: List[CaseDef]): Match = new Match(selector, cases)
-  def InlineMatch(selector: Tree, cases: List[CaseDef]): Match = new InlineMatch(selector, cases)
   def CaseDef(pat: Tree, guard: Tree, body: Tree): CaseDef = new CaseDef(pat, guard, body)
   def Labeled(bind: Bind, expr: Tree): Labeled = new Labeled(bind, expr)
   def Return(expr: Tree, from: Tree): Return = new Return(expr, from)
@@ -544,8 +542,6 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
         cpy.ContextBounds(tree)(transformSub(bounds), transform(cxBounds))
       case PatDef(mods, pats, tpt, rhs) =>
         cpy.PatDef(tree)(mods, transform(pats), transform(tpt), transform(rhs))
-      case tpd.UntypedSplice(splice) =>
-        cpy.UntypedSplice(tree)(transform(splice))
       case TypedSplice(_) =>
         tree
       case _ =>
@@ -595,8 +591,6 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
         this(this(this(x, pats), tpt), rhs)
       case TypedSplice(splice) =>
         this(x, splice)
-      case tpd.UntypedSplice(splice) =>
-        this(x, splice)
       case _ =>
         super.foldMoreCases(x, tree)
     }

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

@@ -786,16 +786,10 @@ class TreePickler(pickler: TastyPickler) {
         withLength { pickleUntyped(expr); stats.foreach(pickleUntyped) }
       case If(cond, thenp, elsep) =>
         writeByte(IF)
-        withLength {
-          if (tree.isInstanceOf[untpd.InlineIf]) writeByte(INLINE)
-          pickleUntyped(cond); pickleUntyped(thenp); pickleUntyped(elsep)
-        }
+        withLength { pickleUntyped(cond); pickleUntyped(thenp); pickleUntyped(elsep) }
       case Match(selector, cases) =>
         writeByte(MATCH)
-        withLength {
-          if (tree.isInstanceOf[untpd.InlineMatch]) writeByte(INLINE)
-          pickleUntyped(selector); cases.foreach(pickleUntyped)
-        }
+        withLength { pickleUntyped(selector); cases.foreach(pickleUntyped) }
       case CaseDef(pat, guard, rhs) =>
         writeByte(CASEDEF)
         withLength { pickleUntyped(pat); pickleUntyped(rhs); pickleUnlessEmpty(guard) }

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

@@ -1332,13 +1332,10 @@ class TreeUnpickler(reader: TastyReader,
             val stats = until(end)(readUntyped())
             untpd.Block(stats, expr)
           case IF =>
-            val mkIf = if (nextByte == INLINE) { readByte(); untpd.InlineIf(_, _, _) }
-              else untpd.If(_, _, _)
+            val mkIf = untpd.If(_, _, _)
             mkIf(readUntyped(), readUntyped(), readUntyped())
           case MATCH =>
-            val mkMatch =
-              if (nextByte == INLINE) { readByte(); untpd.InlineMatch(_, _) }
-              else untpd.Match(_, _)
+            val mkMatch = untpd.Match(_, _)
             mkMatch(readUntyped(), readCases(end))
           case CASEDEF =>
             val pat = readUntyped()

compiler/src/dotty/tools/dotc/parsing/Parsers.scala

@@ -1214,21 +1214,7 @@ object Parsers {
       case FOR =>
         forExpr()
       case _ =>
-        if (isIdent(nme.INLINEkw)) {
-          val start = in.skipToken()
-          in.token match {
-            case IF =>
-              ifExpr(start, InlineIf)
-            case _ =>
-              val t = postfixExpr()
-              if (in.token == MATCH) matchExpr(t, start, InlineMatch)
-              else {
-                syntaxErrorOrIncomplete("`match` or `if` expected but ${in.token} found")
-                t
-              }
-          }
-        }
-        else expr1Rest(postfixExpr(), location)
+        expr1Rest(postfixExpr(), location)
     }
 
     def expr1Rest(t: Tree, location: Location.Value) = in.token match {
@@ -1242,7 +1228,7 @@ object Parsers {
       case COLON =>
         ascription(t, location)
       case MATCH =>
-        matchExpr(t, startOffset(t), Match)
+        matchExpr(t, startOffset(t))
       case _ =>
         t
     }
@@ -1289,9 +1275,9 @@ object Parsers {
     /**    `match' { CaseClauses }
      *     `match' { ImplicitCaseClauses }
      */
-    def matchExpr(t: Tree, start: Offset, mkMatch: (Tree, List[CaseDef]) => Match) =
+    def matchExpr(t: Tree, start: Offset) =
       atPos(start, in.skipToken()) {
-        inBraces(mkMatch(t, caseClauses(caseClause)))
+        inBraces(Match(t, caseClauses(caseClause)))
       }
 
     /**    `match' { ImplicitCaseClauses }
@@ -1306,7 +1292,7 @@ object Parsers {
         case mods => markFirstIllegal(mods)
       }
       val result @ Match(t, cases) =
-        matchExpr(ImplicitScrutinee().withPos(implicitKwPos(start)), start, InlineMatch)
+        matchExpr(ImplicitScrutinee().withPos(implicitKwPos(start)), start)
       for (CaseDef(pat, _, _) <- cases) {
         def isImplicitPattern(pat: Tree) = pat match {
           case Typed(pat1, _) => isVarPattern(pat1)

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

@@ -587,10 +587,6 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(implicit ctx: Context) {
           if (isIdempotentExpr(cond1)) selected
           else Block(cond1 :: Nil, selected)
         case cond1 =>
-          if (tree.isInstanceOf[untpd.InlineIf])
-            errorTree(tree, em"""cannot reduce inline if
-                                | its condition   ${tree.cond}
-                                | is not a constant value.""")
           val if1 = untpd.cpy.If(tree)(cond = untpd.TypedSplice(cond1))
           super.typedIf(if1, pt)
       }

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

@@ -711,7 +711,6 @@ class Typer extends Namer
   }
 
   def typedIf(tree: untpd.If, pt: Type)(implicit ctx: Context): Tree = track("typedIf") {
-    if (tree.isInstanceOf[untpd.InlineIf] && !Inliner.typedInline) checkInInlineContext("inline if", tree.pos)
     val cond1 = typed(tree.cond, defn.BooleanType)
     val thenp2 :: elsep2 :: Nil = harmonic(harmonize) {
       val thenp1 = typed(tree.thenp, pt.notApplied)
@@ -981,7 +980,6 @@ class Typer extends Namer
         val sel1 = id.withType(defn.ImplicitScrutineeTypeRef)
         typedMatchFinish(tree, sel1, sel1.tpe, pt)
       case _ =>
-        if (tree.isInstanceOf[untpd.InlineMatch] && !Inliner.typedInline) checkInInlineContext("inline match", tree.pos)
         val sel1 = typedExpr(tree.selector)
         val selType = fullyDefinedType(sel1.tpe, "pattern selector", tree.pos).widen
         typedMatchFinish(tree, sel1, selType, pt)

library/src-scala3/scala/Tuple.scala

@@ -6,7 +6,7 @@ sealed trait Tuple extends Any {
   import Tuple._
 
   inline def toArray: Array[Object] =
-    if (specialize)
+    /*if (specialize)
       inline constValueOpt[BoundedSize[this.type]] match {
       case Some(0) =>
         $emptyArray
@@ -29,10 +29,10 @@ sealed trait Tuple extends Any {
       case None =>
         dynamicToArray(this)
     }
-    else dynamicToArray(this)
+    else*/ dynamicToArray(this)
 
   inline def *: [H] (x: H): H *: this.type =
-    if (specialize) {
+    /*if (specialize) {
       type Result = H *: this.type
       inline constValueOpt[BoundedSize[this.type]] match {
         case Some(0) =>
@@ -54,10 +54,10 @@ sealed trait Tuple extends Any {
           dynamic_*:[this.type, H](this, x)
       }
     }
-    else dynamic_*:[this.type, H](this, x)
+    else*/ dynamic_*:[this.type, H](this, x)
 
   inline def ++(that: Tuple): Concat[this.type, that.type] =
-    if (specialize) {
+    /*if (specialize) {
       type Result = Concat[this.type, that.type]
       inline constValueOpt[BoundedSize[this.type]] match {
         case Some(0) =>
@@ -95,20 +95,20 @@ sealed trait Tuple extends Any {
           dynamic_++[this.type, that.type](this, that)
       }
     }
-  else dynamic_++[this.type, that.type](this, that)
+  else*/ dynamic_++[this.type, that.type](this, that)
 
   inline def genericConcat[T <: Tuple](xs: Tuple, ys: Tuple): Tuple =
     fromArray[T](xs.toArray ++ ys.toArray)
 
   inline def size: Size[this.type] =
-    if (specialize) {
+    /*if (specialize) {
       type Result = Size[this.type]
       inline constValueOpt[BoundedSize[this.type]] match {
         case Some(n) => n.asInstanceOf[Result]
         case _ => dynamicSize(this)
       }
     }
-    else dynamicSize(this)
+    else*/ dynamicSize(this)
 }
 
 object Tuple {
@@ -175,7 +175,7 @@ object Tuple {
   }
 
   inline def fromArray[T <: Tuple](xs: Array[Object]): T =
-    if (specialize)
+    /*if (specialize)
       inline constValue[BoundedSize[T]] match {
         case 0  => ().asInstanceOf[T]
         case 1  => Tuple1(xs(0)).asInstanceOf[T]
@@ -202,7 +202,7 @@ object Tuple {
         case 22 => Tuple22(xs(0), xs(1), xs(2), xs(3), xs(4), xs(5), xs(6), xs(7), xs(8), xs(9), xs(10), xs(11), xs(12), xs(13), xs(14), xs(15), xs(16), xs(17), xs(18), xs(19), xs(20), xs(21)).asInstanceOf[T]
         case _ => TupleXXL(xs).asInstanceOf[T]
       }
-    else dynamicFromArray[T](xs)
+    else */dynamicFromArray[T](xs)
 
   def dynamicFromArray[T <: Tuple](xs: Array[Object]): T = xs.length match {
     case 0  => ().asInstanceOf[T]
@@ -297,7 +297,7 @@ abstract sealed class NonEmptyTuple extends Tuple {
   import NonEmptyTuple._
 
   inline def head: Head[this.type] =
-    if (specialize) {
+    /*if (specialize) {
       type Result = Head[this.type]
       val resVal = inline constValueOpt[BoundedSize[this.type]] match {
         case Some(1) =>
@@ -322,10 +322,10 @@ abstract sealed class NonEmptyTuple extends Tuple {
       }
       resVal.asInstanceOf[Result]
     }
-    else dynamicHead[this.type](this)
+    else*/ dynamicHead[this.type](this)
 
   inline def tail: Tail[this.type] =
-    if (specialize) {
+    /*if (specialize) {
       type Result = Tail[this.type]
       inline constValueOpt[BoundedSize[this.type]]  match {
         case Some(1) =>
@@ -348,16 +348,18 @@ abstract sealed class NonEmptyTuple extends Tuple {
           dynamicTail[this.type](this)
       }
     }
-    else dynamicTail[this.type](this)
+    else*/ dynamicTail[this.type](this)
 
+  /*
   inline def fallbackApply(n: Int) =
     inline constValueOpt[n.type] match {
       case Some(n: Int) => error("index out of bounds: ", n)
       case None => dynamicApply[this.type](this, n)
     }
+  */
 
   inline def apply(n: Int): Elem[this.type, n.type] =
-    if (specialize) {
+    /*if (specialize) {
       type Result = Elem[this.type, n.type]
       inline constValueOpt[Size[this.type]] match {
         case Some(1) =>
@@ -405,7 +407,7 @@ abstract sealed class NonEmptyTuple extends Tuple {
         case _ => fallbackApply(n).asInstanceOf[Result]
       }
     }
-    else dynamicApply[this.type](this, n)
+    else*/ dynamicApply[this.type](this, n)
 }
 
 object NonEmptyTuple {

tests/neg/nested-rewrites.scala

@@ -15,14 +15,14 @@ object Test {
 object Test0 {
 
   def f(x: Int) = {
-    inline def g(x: Int) = inline x match {
+    inline def g(x: Int) = x match {
       case 0 => 0
     }
     g(0)
     inline val Y = 0
     g(Y)
 
-    inline def h(x: Int) = inline x match {
+    inline def h(x: Int) = x match {
       case Y => 0
     }
     h(0)
@@ -35,14 +35,14 @@ object Test0 {
 object Test1 {
 
   erased inline def f(x: Int) = {
-    erased inline def g(x: Int) = inline x match { // error: implementation restriction: nested inline methods are not supported
+    erased inline def g(x: Int) = x match { // error: implementation restriction: nested inline methods are not supported
       case 0 => 0
     }
     g(0)
     inline val Y = 0
     g(Y)
 
-    inline def h(x: Int) = inline x match { // error: implementation restriction: nested inline methods are not supported
+    inline def h(x: Int) = x match { // error: implementation restriction: nested inline methods are not supported
       case Y => 0
     }
     h(0)

tests/neg/transparent-override/B_2.scala

@@ -1,5 +1,5 @@
 class B extends A {
-  inline def f(x: Int): Int = inline x match { // error
+  inline def f(x: Int): Int = x match { // error
     case 0 => 1
     case _ => x
   }