Merge branch 'master' into cleanup-tests

Author: OlivierBlanvillain

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

@@ -725,6 +725,31 @@ object desugar {
       tree
   }
 
+  /** Translate infix operation expression
+    *
+    *     l op r     ==>    l.op(r)  if op is left-associative
+    *                ==>    r.op(l)  if op is right-associative
+    */
+  def binop(left: Tree, op: Ident, right: Tree)(implicit ctx: Context): Apply = {
+    def assignToNamedArg(arg: Tree) = arg match {
+      case Assign(Ident(name), rhs) => cpy.NamedArg(arg)(name, rhs)
+      case _ => arg
+    }
+    def makeOp(fn: Tree, arg: Tree, selectPos: Position) = {
+      val args: List[Tree] = arg match {
+        case Parens(arg) => assignToNamedArg(arg) :: Nil
+        case Tuple(args) => args.mapConserve(assignToNamedArg)
+        case _ => arg :: Nil
+      }
+      Apply(Select(fn, op.name).withPos(selectPos), args)
+    }
+
+    if (isLeftAssoc(op.name))
+      makeOp(left, right, Position(left.pos.start, op.pos.end, op.pos.start))
+    else
+      makeOp(right, left, Position(op.pos.start, right.pos.end))
+  }
+
   /** Make closure corresponding to function.
    *      params => body
    *  ==>
@@ -832,30 +857,6 @@ object desugar {
       Block(ldef, call)
     }
 
-    /** Translate infix operation expression  left op right
-     */
-    def makeBinop(left: Tree, op: Ident, right: Tree): Tree = {
-      def assignToNamedArg(arg: Tree) = arg match {
-        case Assign(Ident(name), rhs) => cpy.NamedArg(arg)(name, rhs)
-        case _ => arg
-      }
-      if (isLeftAssoc(op.name)) {
-        val args: List[Tree] = right match {
-          case Parens(arg) => assignToNamedArg(arg) :: Nil
-          case Tuple(args) => args mapConserve assignToNamedArg
-          case _ => right :: Nil
-        }
-        val selectPos = Position(left.pos.start, op.pos.end, op.pos.start)
-        Apply(Select(left, op.name).withPos(selectPos), args)
-      } else {
-        val x = UniqueName.fresh()
-        val selectPos = Position(op.pos.start, right.pos.end, op.pos.start)
-        new InfixOpBlock(
-          ValDef(x, TypeTree(), left).withMods(synthetic),
-          Apply(Select(right, op.name).withPos(selectPos), Ident(x).withPos(left.pos)))
-      }
-    }
-
     /** 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.
@@ -1066,10 +1067,10 @@ object desugar {
           if (!op.isBackquoted && op.name == tpnme.raw.AMP) AndTypeTree(l, r)     // l & r
           else if (!op.isBackquoted && op.name == tpnme.raw.BAR) OrTypeTree(l, r) // l | r
           else AppliedTypeTree(op, l :: r :: Nil) // op[l, r]
-        else if (ctx.mode is Mode.Pattern)
+        else {
+          assert(ctx.mode is Mode.Pattern) // expressions are handled separately by `binop`
           Apply(op, l :: r :: Nil) // op(l, r)
-        else // l.op(r), or val x = r; l.op(x), plus handle named args specially
-          makeBinop(l, op, r)
+        }
       case PostfixOp(t, op) =>
         if ((ctx.mode is Mode.Type) && !op.isBackquoted && op.name == tpnme.raw.STAR) {
           val seqType = if (ctx.compilationUnit.isJava) defn.ArrayType else defn.SeqType

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

@@ -311,9 +311,9 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
   import tpd._
 
   /** The purity level of this statement.
-   *  @return   pure        if statement has no side effects
-   *            idempotent  if running the statement a second time has no side effects
-   *            impure      otherwise
+   *  @return   Pure        if statement has no side effects
+   *            Idempotent  if running the statement a second time has no side effects
+   *            Impure      otherwise
    */
   private def statPurity(tree: Tree)(implicit ctx: Context): PurityLevel = unsplice(tree) match {
     case EmptyTree
@@ -322,17 +322,18 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
        | DefDef(_, _, _, _, _) =>
       Pure
     case vdef @ ValDef(_, _, _) =>
-      if (vdef.symbol.flags is Mutable) Impure else exprPurity(vdef.rhs)
+      if (vdef.symbol.flags is Mutable) Impure else exprPurity(vdef.rhs) `min` Pure
     case _ =>
       Impure
       // TODO: It seem like this should be exprPurity(tree)
       // But if we do that the repl/vars test break. Need to figure out why that's the case.
   }
 
   /** The purity level of this expression.
-   *  @return   pure        if expression has no side effects
-   *            idempotent  if running the expression a second time has no side effects
-   *            impure      otherwise
+   *  @return   SimplyPure  if expression has no side effects and cannot contain local definitions
+   *            Pure        if expression has no side effects
+   *            Idempotent  if running the expression a second time has no side effects
+   *            Impure      otherwise
    *
    *  Note that purity and idempotency are different. References to modules and lazy
    *  vals are impure (side-effecting) both because side-effecting code may be executed and because the first reference
@@ -345,7 +346,7 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
        | Super(_, _)
        | Literal(_)
        | Closure(_, _, _) =>
-      Pure
+      SimplyPure
     case Ident(_) =>
       refPurity(tree)
     case Select(qual, _) =>
@@ -366,7 +367,7 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
       if (args.isEmpty && fn.symbol.is(Stable)) exprPurity(fn)
       else if (tree.tpe.isInstanceOf[ConstantType] && isKnownPureOp(tree.symbol))
         // A constant expression with pure arguments is pure.
-        minOf(exprPurity(fn), args.map(exprPurity))
+        minOf(exprPurity(fn), args.map(exprPurity)) `min` Pure
       else Impure
     case Typed(expr, _) =>
       exprPurity(expr)
@@ -382,25 +383,26 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
 
   private def minOf(l0: PurityLevel, ls: List[PurityLevel]) = (l0 /: ls)(_ min _)
 
-  def isPureExpr(tree: Tree)(implicit ctx: Context) = exprPurity(tree) == Pure
+  def isSimplyPure(tree: Tree)(implicit ctx: Context) = exprPurity(tree) == SimplyPure
+  def isPureExpr(tree: Tree)(implicit ctx: Context) = exprPurity(tree) >= Pure
   def isIdempotentExpr(tree: Tree)(implicit ctx: Context) = exprPurity(tree) >= Idempotent
 
   /** The purity level of this reference.
    *  @return
-   *    pure        if reference is (nonlazy and stable) or to a parameterized function
-   *    idempotent  if reference is lazy and stable
-   *    impure      otherwise
+   *    SimplyPure  if reference is (nonlazy and stable) or to a parameterized function
+   *    Idempotent  if reference is lazy and stable
+   *    Impure      otherwise
    *  @DarkDimius: need to make sure that lazy accessor methods have Lazy and Stable
    *               flags set.
    */
   private def refPurity(tree: Tree)(implicit ctx: Context): PurityLevel =
-    if (!tree.tpe.widen.isParameterless) Pure
+    if (!tree.tpe.widen.isParameterless) SimplyPure
     else if (!tree.symbol.isStable) Impure
     else if (tree.symbol.is(Lazy)) Idempotent // TODO add Module flag, sinxce Module vals or not Lazy from the start.
-    else Pure
+    else SimplyPure
 
   def isPureRef(tree: Tree)(implicit ctx: Context) =
-    refPurity(tree) == Pure
+    refPurity(tree) == SimplyPure
   def isIdempotentRef(tree: Tree)(implicit ctx: Context) =
     refPurity(tree) >= Idempotent
 
@@ -554,6 +556,7 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
     val acc = new TreeAccumulator[List[Symbol]] {
       def apply(syms: List[Symbol], tree: Tree)(implicit ctx: Context) = tree match {
         case Bind(_, body) => apply(tree.symbol :: syms, body)
+        case Annotated(tree, id @ Ident(tpnme.BOUNDTYPE_ANNOT)) => apply(id.symbol :: syms, tree)
         case _ => foldOver(syms, tree)
       }
     }
@@ -724,6 +727,7 @@ object TreeInfo {
     def min(that: PurityLevel) = new PurityLevel(x min that.x)
   }
 
+  val SimplyPure = new PurityLevel(3)
   val Pure = new PurityLevel(2)
   val Idempotent = new PurityLevel(1)
   val Impure = new PurityLevel(0)

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

@@ -7,6 +7,7 @@ import Types._, Contexts._, Constants._, Names._, Flags._
 import SymDenotations._, Symbols._, Annotations._, Trees._, Symbols._
 import Denotations._, Decorators._
 import dotty.tools.dotc.transform.SymUtils._
+import core.tasty.TreePickler.Hole
 
 /** A map that applies three functions and a substitution together to a tree and
  *  makes sure they are coordinated so that the result is well-typed. The functions are
@@ -115,6 +116,8 @@ class TreeTypeMap(
           val guard1 = tmap.transform(guard)
           val rhs1 = tmap.transform(rhs)
           cpy.CaseDef(cdef)(pat1, guard1, rhs1)
+        case Hole(n, args) =>
+          Hole(n, args.mapConserve(transform)).withPos(tree.pos).withType(mapType(tree.tpe))
         case tree1 =>
           super.transform(tree1)
       }
@@ -154,7 +157,7 @@ class TreeTypeMap(
       assert(!to.exists(substFrom contains _))
       assert(!from.exists(newOwners contains _))
       assert(!to.exists(oldOwners contains _))
-      newMap(
+      new TreeTypeMap(
         typeMap,
         treeMap,
         from ++ oldOwners,
@@ -163,16 +166,6 @@ class TreeTypeMap(
         to ++ substTo)
     }
 
-  /** A new map of the same class this one */
-  protected def newMap(
-      typeMap: Type => Type,
-      treeMap: Tree => Tree,
-      oldOwners: List[Symbol],
-      newOwners: List[Symbol],
-      substFrom: List[Symbol],
-      substTo: List[Symbol])(implicit ctx: Context) =
-    new TreeTypeMap(typeMap, treeMap, oldOwners, newOwners, substFrom, substTo)
-
   /** Apply `typeMap` and `ownerMap` to given symbols `syms`
    *  and return a treemap that contains the substitution
    *  between original and mapped symbols.

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

@@ -96,16 +96,6 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
     override def isEmpty = true
   }
 
-  /** A block arising from a right-associative infix operation, where, e.g.
-   *
-   *     a +: b
-   *
-   *  is expanded to
-   *
-   *     { val x = a; b.+:(x) }
-   */
-  class InfixOpBlock(leftOperand: Tree, rightOp: Tree) extends Block(leftOperand :: Nil, rightOp)
-
   /** A block generated by the XML parser, only treated specially by
    *  `Positioned#checkPos` */
   class XMLBlock(stats: List[Tree], expr: Tree) extends Block(stats, expr)

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

@@ -77,6 +77,7 @@ class ScalaSettings extends Settings.SettingGroup {
   val Ydebug = BooleanSetting("-Ydebug", "Increase the quantity of debugging output.")
   val YdebugTrace = BooleanSetting("-Ydebug-trace", "Trace core operations")
   val YdebugFlags = BooleanSetting("-Ydebug-flags", "Print all flags of definitions")
+  val YdebugMissingRefs = BooleanSetting("-Ydebug-missing-refs", "Print a stacktrace when a required symbol is missing")
   val YdebugNames = BooleanSetting("-Ydebug-names", "Show internal representation of names")
   val YdebugOwners = BooleanSetting("-Ydebug-owners", "Print all owners of definitions (requires -Yprint-syms)")
   val YtermConflict = ChoiceSetting("-Yresolve-term-conflict", "strategy", "Resolve term conflicts", List("package", "object", "error"), "error")

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

@@ -277,7 +277,7 @@ object Denotations {
       disambiguate(p) match {
         case m @ MissingRef(ownerd, name) =>
           if (generateStubs) {
-            m.ex.printStackTrace()
+            if (ctx.settings.YdebugMissingRefs.value) m.ex.printStackTrace()
             ctx.newStubSymbol(ownerd.symbol, name, source)
           }
           else NoSymbol
@@ -1115,7 +1115,7 @@ object Denotations {
    *  Produced by staticRef, consumed by requiredSymbol.
    */
   case class MissingRef(val owner: SingleDenotation, name: Name)(implicit ctx: Context) extends ErrorDenotation {
-    val ex: Exception = new Exception
+    val ex: Exception = new Exception // DEBUG
   }
 
   /** An error denotation that provides more info about alternatives

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

@@ -143,6 +143,7 @@ object StdNames {
     val INITIALIZER_PREFIX: N         = "initial$"
     val COMPANION_MODULE_METHOD: N    = "companion$module"
     val COMPANION_CLASS_METHOD: N     = "companion$class"
+    val BOUNDTYPE_ANNOT: N            = "$boundType$"
     val QUOTE: N                      = "'"
     val TYPE_QUOTE: N                = "type_'"
     val TRAIT_SETTER_SEPARATOR: N     = str.TRAIT_SETTER_SEPARATOR

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

@@ -5,6 +5,7 @@ package core
 import Periods._, Contexts._, Symbols._, Denotations._, Names._, NameOps._, Annotations._
 import Types._, Flags._, Decorators._, DenotTransformers._, StdNames._, Scopes._, Comments._
 import NameOps._, NameKinds._, Phases._
+import TypeApplications.TypeParamInfo
 import Scopes.Scope
 import collection.mutable
 import collection.BitSet
@@ -1915,6 +1916,11 @@ object SymDenotations {
       override def complete(denot: SymDenotation)(implicit ctx: Context) = self.complete(denot)
     }
 
+    /** The type parameters computed by the completer before completion has finished */
+    def completerTypeParams(sym: Symbol)(implicit ctx: Context): List[TypeParamInfo] =
+      if (sym is Touched) Nil // return `Nil` instead of throwing a cyclic reference
+      else sym.info.typeParams
+
     def decls: Scope = myDecls
     def sourceModule(implicit ctx: Context): Symbol = mySourceModuleFn(ctx)
     def moduleClass(implicit ctx: Context): Symbol = myModuleClassFn(ctx)
@@ -1924,12 +1930,12 @@ object SymDenotations {
     def withModuleClass(moduleClassFn: Context => Symbol): this.type = { myModuleClassFn = moduleClassFn; this }
   }
 
-  /** A subclass of LazyTypes where type parameters can be completed independently of
-   *  the info.
+  /** A subtrait of LazyTypes where completerTypeParams yields a List[TypeSymbol], which
+   *  should be completed independently of the info.
    */
   trait TypeParamsCompleter extends LazyType {
-    /** The type parameters computed by the completer before completion has finished */
-    def completerTypeParams(sym: Symbol)(implicit ctx: Context): List[TypeSymbol]
+    override def completerTypeParams(sym: Symbol)(implicit ctx: Context): List[TypeSymbol] =
+      unsupported("completerTypeParams") // should be abstract, but Scala-2 will then compute the wrong type for it
   }
 
   val NoSymbolFn = (ctx: Context) => NoSymbol

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

@@ -243,7 +243,6 @@ trait Symbols { this: Context =>
       case name: TypeName =>
         newClassSymbol(normalizedOwner, name, EmptyFlags, stubCompleter, assocFile = file)
     }
-    stubs = stub :: stubs
     stub
   }
 
@@ -377,7 +376,10 @@ trait Symbols { this: Context =>
   def requiredPackageRef(path: PreName): TermRef = requiredPackage(path).termRef
 
   def requiredClass(path: PreName): ClassSymbol =
-    base.staticRef(path.toTypeName).requiredSymbol(_.isClass).asClass
+    base.staticRef(path.toTypeName).requiredSymbol(_.isClass) match {
+      case cls: ClassSymbol => cls
+      case sym => defn.AnyClass
+    }
 
   def requiredClassRef(path: PreName): TypeRef = requiredClass(path).typeRef
 
@@ -700,8 +702,6 @@ object Symbols {
   /** The current class */
   def currentClass(implicit ctx: Context): ClassSymbol = ctx.owner.enclosingClass.asClass
 
-  @sharable var stubs: List[Symbol] = Nil // diagnostic only
-
   /* Mutable map from symbols any T */
   class MutableSymbolMap[T](private[Symbols] val value: java.util.IdentityHashMap[Symbol, T]) extends AnyVal {
 

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

@@ -172,8 +172,11 @@ class TypeApplications(val self: Type) extends AnyVal {
       case self: TypeRef =>
         val tsym = self.symbol
         if (tsym.isClass) tsym.typeParams
-        else if (!tsym.isCompleting) tsym.info.typeParams
-        else Nil
+        else if (!tsym.exists) self.info.typeParams
+        else tsym.infoOrCompleter match {
+          case info: LazyType => info.completerTypeParams(tsym)
+          case info => info.typeParams
+        }
       case self: AppliedType =>
         if (self.tycon.typeSymbol.isClass) Nil
         else self.superType.typeParams