Merge branch 'master' into add-transparent-7

Author: OlivierBlanvillain

bench/tests/power-macro/PowerMacro.scala

@@ -2,7 +2,7 @@ import scala.quoted.Expr
 
 object PowerMacro {
 
-  rewrite def power(transparent n: Long, x: Double) = ~powerCode(n, '(x))
+  inline def power(inline n: Long, x: Double) = ~powerCode(n, '(x))
 
   def powerCode(n: Long, x: Expr[Double]): Expr[Double] =
     if (n == 0) '(1.0)

compiler/src/dotty/tools/backend/jvm/DottyBackendInterface.scala

@@ -63,6 +63,7 @@ class DottyBackendInterface(outputDirectory: AbstractFile, val superCallsMap: Ma
   type Throw           = tpd.Apply
   type Labeled         = tpd.Labeled
   type Return          = tpd.Return
+  type WhileDo         = tpd.WhileDo
   type Block           = tpd.Block
   type Typed           = tpd.Typed
   type Match           = tpd.Match
@@ -196,6 +197,7 @@ class DottyBackendInterface(outputDirectory: AbstractFile, val superCallsMap: Ma
   implicit val ThrowTag: ClassTag[Throw] = ClassTag[Throw](classOf[Throw])
   implicit val LabeledTag: ClassTag[Labeled] = ClassTag[Labeled](classOf[Labeled])
   implicit val ReturnTag: ClassTag[Return] = ClassTag[Return](classOf[Return])
+  implicit val WhileDoTag: ClassTag[WhileDo] = ClassTag[WhileDo](classOf[WhileDo])
   implicit val LiteralTag: ClassTag[Literal] = ClassTag[Literal](classOf[Literal])
   implicit val BlockTag: ClassTag[Block] = ClassTag[Block](classOf[Block])
   implicit val TypedTag: ClassTag[Typed] = ClassTag[Typed](classOf[Typed])
@@ -1088,6 +1090,11 @@ class DottyBackendInterface(outputDirectory: AbstractFile, val superCallsMap: Ma
     def _2: Symbol = if (field.from.symbol.isLabel) field.from.symbol else NoSymbol
   }
 
+  object WhileDo extends WhileDoDeconstructor {
+    def _1: Tree = field.cond
+    def _2: Tree = field.body
+  }
+
   object Ident extends IdentDeconstructor {
     def get = field.name
   }

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

@@ -928,13 +928,6 @@ object desugar {
   /** Main desugaring method */
   def apply(tree: Tree)(implicit ctx: Context): Tree = {
 
-    /**    { label def lname(): Unit = rhs; call }
-     */
-    def labelDefAndCall(lname: TermName, rhs: Tree, call: Tree) = {
-      val ldef = DefDef(lname, Nil, ListOfNil, TypeTree(defn.UnitType), rhs).withFlags(Label | Synthetic)
-      Block(ldef, call)
-    }
-
     /** Create tree for for-comprehension `<for (enums) do body>` or
      *   `<for (enums) yield body>` where mapName and flatMapName are chosen
      *  corresponding to whether this is a for-do or a for-yield.
@@ -1159,16 +1152,10 @@ object desugar {
       case PrefixOp(op, t) =>
         val nspace = if (ctx.mode.is(Mode.Type)) tpnme else nme
         Select(t, nspace.UNARY_PREFIX ++ op.name)
-      case WhileDo(cond, body) =>
-        // { <label> def while$(): Unit = if (cond) { body; while$() } ; while$() }
-        val call = Apply(Ident(nme.WHILE_PREFIX), Nil).withPos(tree.pos)
-        val rhs = If(cond, Block(body, call), unitLiteral)
-        labelDefAndCall(nme.WHILE_PREFIX, rhs, call)
       case DoWhile(body, cond) =>
-        // { label def doWhile$(): Unit = { body; if (cond) doWhile$() } ; doWhile$() }
-        val call = Apply(Ident(nme.DO_WHILE_PREFIX), Nil).withPos(tree.pos)
-        val rhs = Block(body, If(cond, call, unitLiteral))
-        labelDefAndCall(nme.DO_WHILE_PREFIX, rhs, call)
+        // while ({ { body }; { cond } }) { () }
+        // the inner blocks are there to protect the scopes of body and cond from each other
+        WhileDo(Block(Block(Nil, body), Block(Nil, cond)), Literal(Constant(())))
       case ForDo(enums, body) =>
         makeFor(nme.foreach, nme.foreach, enums, body) orElse tree
       case ForYield(enums, body) =>

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

@@ -306,6 +306,7 @@ trait UntypedTreeInfo extends TreeInfo[Untyped] { self: Trees.Instance[Untyped]
     case mdef: TypeDef =>
       def isBounds(rhs: Tree): Boolean = rhs match {
         case _: TypeBoundsTree => true
+        case _: MatchTypeTree => true // Typedefs with Match rhs classify as abstract
         case LambdaTypeTree(_, body) => isBounds(body)
         case _ => false
       }
@@ -392,20 +393,21 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
     case Ident(_) =>
       refPurity(tree)
     case Select(qual, _) =>
-      refPurity(tree).min(exprPurity(qual))
+      if (tree.symbol.is(Erased)) Pure
+      else refPurity(tree).min(exprPurity(qual))
     case New(_) =>
       SimplyPure
     case TypeApply(fn, _) =>
-      exprPurity(fn)
+      if (fn.symbol.is(Erased)) Pure else exprPurity(fn)
     case Apply(fn, args) =>
       def isKnownPureOp(sym: Symbol) =
         sym.owner.isPrimitiveValueClass || sym.owner == defn.StringClass
       if (tree.tpe.isInstanceOf[ConstantType] && isKnownPureOp(tree.symbol)
              // A constant expression with pure arguments is pure.
           || fn.symbol.isStable)
         minOf(exprPurity(fn), args.map(exprPurity)) `min` Pure
-      else
-        Impure
+      else if (fn.symbol.is(Erased)) Pure
+      else Impure
     case Typed(expr, _) =>
       exprPurity(expr)
     case Block(stats, expr) =>
@@ -462,11 +464,11 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
    *  Strictly speaking we can't replace `O.x` with `42`.  But this would make
    *  most expressions non-constant. Maybe we can change the spec to accept this
    *  kind of eliding behavior. Or else enforce true purity in the compiler.
-   *  The choice will be affected by what we will do with `transparent` and with
+   *  The choice will be affected by what we will do with `inline` and with
    *  Singleton type bounds (see SIP 23). Presumably
    *
    *     object O1 { val x: Singleton = 42; println("43") }
-   *     object O2 { transparent val x = 42; println("43") }
+   *     object O2 { inline val x = 42; println("43") }
    *
    *  should behave differently.
    *
@@ -476,8 +478,8 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
    *
    *     O2.x = 42
    *
-   *  Revisit this issue once we have standardized on `transparent`. Then we can demand
-   *  purity of the prefix unless the selection goes to a transparent val.
+   *  Revisit this issue once we have standardized on `inline`. Then we can demand
+   *  purity of the prefix unless the selection goes to a inline val.
    *
    *  Note: This method should be applied to all term tree nodes that are not literals,
    *        that can be idempotent, and that can have constant types. So far, only nodes

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

@@ -498,9 +498,9 @@ object Trees {
     extends TermTree[T] {
     type ThisTree[-T >: Untyped] = If[T]
   }
-  class RewriteIf[T >: Untyped] private[ast] (cond: Tree[T], thenp: Tree[T], elsep: Tree[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"RewriteIf($cond, $thenp, $elsep)"
+    override def toString = s"InlineIf($cond, $thenp, $elsep)"
   }
 
   /** A closure with an environment and a reference to a method.
@@ -522,9 +522,9 @@ object Trees {
     extends TermTree[T] {
     type ThisTree[-T >: Untyped] = Match[T]
   }
-  class RewriteMatch[T >: Untyped] private[ast] (selector: Tree[T], cases: List[CaseDef[T]])
+  class InlineMatch[T >: Untyped] private[ast] (selector: Tree[T], cases: List[CaseDef[T]])
     extends Match(selector, cases) {
-    override def toString = s"RewriteMatch($selector, $cases)"
+    override def toString = s"InlineMatch($selector, $cases)"
   }
 
   /** case pat if guard => body; only appears as child of a Match */
@@ -550,6 +550,12 @@ object Trees {
     type ThisTree[-T >: Untyped] = Return[T]
   }
 
+  /** while (cond) { body } */
+  case class WhileDo[-T >: Untyped] private[ast] (cond: Tree[T], body: Tree[T])
+    extends TermTree[T] {
+    type ThisTree[-T >: Untyped] = WhileDo[T]
+  }
+
   /** try block catch handler finally finalizer
    *
    *  Note: if the handler is a case block CASES of the form
@@ -662,6 +668,12 @@ object Trees {
     type ThisTree[-T >: Untyped] = LambdaTypeTree[T]
   }
 
+  /** [bound] selector match { cases } */
+  case class MatchTypeTree[-T >: Untyped] private[ast] (bound: Tree[T], selector: Tree[T], cases: List[CaseDef[T]])
+    extends TypTree[T] {
+    type ThisTree[-T >: Untyped] = MatchTypeTree[T]
+  }
+
   /** => T */
   case class ByNameTypeTree[-T >: Untyped] private[ast] (result: Tree[T])
   extends TypTree[T] {
@@ -899,13 +911,14 @@ object Trees {
     type Assign = Trees.Assign[T]
     type Block = Trees.Block[T]
     type If = Trees.If[T]
-    type RewriteIf = Trees.RewriteIf[T]
+    type InlineIf = Trees.InlineIf[T]
     type Closure = Trees.Closure[T]
     type Match = Trees.Match[T]
-    type RewriteMatch = Trees.RewriteMatch[T]
+    type InlineMatch = Trees.InlineMatch[T]
     type CaseDef = Trees.CaseDef[T]
     type Labeled = Trees.Labeled[T]
     type Return = Trees.Return[T]
+    type WhileDo = Trees.WhileDo[T]
     type Try = Trees.Try[T]
     type SeqLiteral = Trees.SeqLiteral[T]
     type JavaSeqLiteral = Trees.JavaSeqLiteral[T]
@@ -917,6 +930,7 @@ object Trees {
     type RefinedTypeTree = Trees.RefinedTypeTree[T]
     type AppliedTypeTree = Trees.AppliedTypeTree[T]
     type LambdaTypeTree = Trees.LambdaTypeTree[T]
+    type MatchTypeTree = Trees.MatchTypeTree[T]
     type ByNameTypeTree = Trees.ByNameTypeTree[T]
     type TypeBoundsTree = Trees.TypeBoundsTree[T]
     type Bind = Trees.Bind[T]
@@ -1032,9 +1046,9 @@ 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: RewriteIf =>
+        case tree: InlineIf =>
           if ((cond eq tree.cond) && (thenp eq tree.thenp) && (elsep eq tree.elsep)) tree
-          else finalize(tree, untpd.RewriteIf(cond, thenp, elsep))
+          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))
       }
@@ -1043,9 +1057,9 @@ 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: RewriteMatch =>
+        case tree: InlineMatch =>
           if ((selector eq tree.selector) && (cases eq tree.cases)) tree
-          else finalize(tree, untpd.RewriteMatch(selector, cases))
+          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))
       }
@@ -1061,6 +1075,10 @@ object Trees {
         case tree: Return if (expr eq tree.expr) && (from eq tree.from) => tree
         case _ => finalize(tree, untpd.Return(expr, from))
       }
+      def WhileDo(tree: Tree)(cond: Tree, body: Tree)(implicit ctx: Context): WhileDo = tree match {
+        case tree: WhileDo if (cond eq tree.cond) && (body eq tree.body) => tree
+        case _ => finalize(tree, untpd.WhileDo(cond, body))
+      }
       def Try(tree: Tree)(expr: Tree, cases: List[CaseDef], finalizer: Tree)(implicit ctx: Context): Try = tree match {
         case tree: Try if (expr eq tree.expr) && (cases eq tree.cases) && (finalizer eq tree.finalizer) => tree
         case _ => finalize(tree, untpd.Try(expr, cases, finalizer))
@@ -1100,6 +1118,10 @@ object Trees {
         case tree: LambdaTypeTree if (tparams eq tree.tparams) && (body eq tree.body) => tree
         case _ => finalize(tree, untpd.LambdaTypeTree(tparams, body))
       }
+      def MatchTypeTree(tree: Tree)(bound: Tree, selector: Tree, cases: List[CaseDef]): MatchTypeTree = tree match {
+        case tree: MatchTypeTree if (bound eq tree.bound) && (selector eq tree.selector) && (cases eq tree.cases) => tree
+        case _ => finalize(tree, untpd.MatchTypeTree(bound, selector, cases))
+      }
       def ByNameTypeTree(tree: Tree)(result: Tree): ByNameTypeTree = tree match {
         case tree: ByNameTypeTree if result eq tree.result => tree
         case _ => finalize(tree, untpd.ByNameTypeTree(result))
@@ -1235,6 +1257,8 @@ object Trees {
             cpy.Labeled(tree)(transformSub(bind), transform(expr))
           case Return(expr, from) =>
             cpy.Return(tree)(transform(expr), transformSub(from))
+          case WhileDo(cond, body) =>
+            cpy.WhileDo(tree)(transform(cond), transform(body))
           case Try(block, cases, finalizer) =>
             cpy.Try(tree)(transform(block), transformSub(cases), transform(finalizer))
           case SeqLiteral(elems, elemtpt) =>
@@ -1256,6 +1280,8 @@ object Trees {
           case LambdaTypeTree(tparams, body) =>
             implicit val ctx = localCtx
             cpy.LambdaTypeTree(tree)(transformSub(tparams), transform(body))
+          case MatchTypeTree(bound, selector, cases) =>
+            cpy.MatchTypeTree(tree)(transform(bound), transform(selector), transformSub(cases))
           case ByNameTypeTree(result) =>
             cpy.ByNameTypeTree(tree)(transform(result))
           case TypeBoundsTree(lo, hi) =>
@@ -1369,6 +1395,8 @@ object Trees {
             this(this(x, bind), expr)
           case Return(expr, from) =>
             this(this(x, expr), from)
+          case WhileDo(cond, body) =>
+            this(this(x, cond), body)
           case Try(block, handler, finalizer) =>
             this(this(this(x, block), handler), finalizer)
           case SeqLiteral(elems, elemtpt) =>
@@ -1390,6 +1418,8 @@ object Trees {
           case LambdaTypeTree(tparams, body) =>
             implicit val ctx = localCtx
             this(this(x, tparams), body)
+          case MatchTypeTree(bound, selector, cases) =>
+            this(this(this(x, bound), selector), cases)
           case ByNameTypeTree(result) =>
             this(x, result)
           case TypeBoundsTree(lo, hi) =>

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

@@ -115,10 +115,10 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
   }
 
   def CaseDef(pat: Tree, guard: Tree, body: Tree)(implicit ctx: Context): CaseDef =
-    ta.assignType(untpd.CaseDef(pat, guard, body), body)
+    ta.assignType(untpd.CaseDef(pat, guard, body), pat, body)
 
   def Match(selector: Tree, cases: List[CaseDef])(implicit ctx: Context): Match =
-    ta.assignType(untpd.Match(selector, cases), cases)
+    ta.assignType(untpd.Match(selector, cases), selector, cases)
 
   def Labeled(bind: Bind, expr: Tree)(implicit ctx: Context): Labeled =
     ta.assignType(untpd.Labeled(bind, expr))
@@ -129,6 +129,9 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
   def Return(expr: Tree, from: Tree)(implicit ctx: Context): Return =
     ta.assignType(untpd.Return(expr, from))
 
+  def WhileDo(cond: Tree, body: Tree)(implicit ctx: Context): WhileDo =
+    ta.assignType(untpd.WhileDo(cond, body))
+
   def Try(block: Tree, cases: List[CaseDef], finalizer: Tree)(implicit ctx: Context): Try =
     ta.assignType(untpd.Try(block, cases, finalizer), block, cases)
 
@@ -165,6 +168,9 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
   def LambdaTypeTree(tparams: List[TypeDef], body: Tree)(implicit ctx: Context): LambdaTypeTree =
     ta.assignType(untpd.LambdaTypeTree(tparams, body), tparams, body)
 
+  def MatchTypeTree(bound: Tree, selector: Tree, cases: List[CaseDef])(implicit ctx: Context): MatchTypeTree =
+    ta.assignType(untpd.MatchTypeTree(bound, selector, cases), bound, selector, cases)
+
   def TypeBoundsTree(lo: Tree, hi: Tree)(implicit ctx: Context): TypeBoundsTree =
     ta.assignType(untpd.TypeBoundsTree(lo, hi), lo, hi)
 
@@ -575,7 +581,6 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
       }
     }
 
-
     override def Closure(tree: Tree)(env: List[Tree], meth: Tree, tpt: Tree)(implicit ctx: Context): Closure = {
       val tree1 = untpd.cpy.Closure(tree)(env, meth, tpt)
       tree match {
@@ -584,6 +589,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
         case _ => ta.assignType(tree1, meth, tpt)
       }
     }
+
     override def Match(tree: Tree)(selector: Tree, cases: List[CaseDef])(implicit ctx: Context): Match = {
       @tailrec
       def sameCases(trees: List[CaseDef], trees1: List[CaseDef]): Boolean = {
@@ -600,15 +606,15 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
       val tree1 = untpd.cpy.Match(tree)(selector, cases)
       tree match {
         case tree: Match if (selector.tpe eq tree.selector.tpe) && sameCases(cases, tree.cases) => tree1.withTypeUnchecked(tree.tpe)
-        case _ => ta.assignType(tree1, cases)
+        case _ => ta.assignType(tree1, selector, cases)
       }
     }
 
     override def CaseDef(tree: Tree)(pat: Tree, guard: Tree, body: Tree)(implicit ctx: Context): CaseDef = {
       val tree1 = untpd.cpy.CaseDef(tree)(pat, guard, body)
       tree match {
         case tree: CaseDef if body.tpe eq tree.body.tpe => tree1.withTypeUnchecked(tree.tpe)
-        case _ => ta.assignType(tree1, body)
+        case _ => ta.assignType(tree1, pat, body)
       }
     }
 
@@ -618,6 +624,9 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     override def Return(tree: Tree)(expr: Tree, from: Tree)(implicit ctx: Context): Return =
       ta.assignType(untpd.cpy.Return(tree)(expr, from))
 
+    override def WhileDo(tree: Tree)(cond: Tree, body: Tree)(implicit ctx: Context): WhileDo =
+      ta.assignType(untpd.cpy.WhileDo(tree)(cond, body))
+
     override def Try(tree: Tree)(expr: Tree, cases: List[CaseDef], finalizer: Tree)(implicit ctx: Context): Try = {
       val tree1 = untpd.cpy.Try(tree)(expr, cases, finalizer)
       tree match {
@@ -833,7 +842,10 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
 
     /** `tree == that` */
     def equal(that: Tree)(implicit ctx: Context) =
-      applyOverloaded(tree, nme.EQ, that :: Nil, Nil, defn.BooleanType)
+      if (that.tpe.widen.isRef(defn.NothingClass))
+        Literal(Constant(false))
+      else
+        applyOverloaded(tree, nme.EQ, that :: Nil, Nil, defn.BooleanType)
 
     /** `tree.isInstanceOf[tp]`, with special treatment of singleton types */
     def isInstance(tp: Type)(implicit ctx: Context): Tree = tp.dealias match {