Merge branch 'master' into 'topic/sbt1'

Author: allanrenucci

compiler/src/dotty/tools/dotc/Compiler.scala

@@ -67,6 +67,7 @@ class Compiler {
          new NormalizeFlags,         // Rewrite some definition flags
          new ExtensionMethods,       // Expand methods of value classes with extension methods
          new ExpandSAMs,             // Expand single abstract method closures to anonymous classes
+         new ShortcutImplicits,      // Allow implicit functions without creating closures
          new TailRec,                // Rewrite tail recursion to loops
          new ByNameClosures,         // Expand arguments to by-name parameters to closures
          new LiftTry,                // Put try expressions that might execute on non-empty stacks into their own methods
@@ -77,7 +78,6 @@ class Compiler {
          new PatternMatcher,         // Compile pattern matches
          new ExplicitOuter,          // Add accessors to outer classes from nested ones.
          new ExplicitSelf,           // Make references to non-trivial self types explicit as casts
-         new ShortcutImplicits,      // Allow implicit functions without creating closures
          new CrossCastAnd,           // Normalize selections involving intersection types.
          new Splitter) ::            // Expand selections involving union types into conditionals
     List(new ErasedDecls,            // Removes all erased defs and vals decls (except for parameters)

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

@@ -50,7 +50,7 @@ object desugar {
    */
   class DerivedFromParamTree(suffix: String) extends DerivedTypeTree {
 
-    /** Make sure that for all enclosing module classes their companion lasses
+    /** Make sure that for all enclosing module classes their companion classes
      *  are completed. Reason: We need the constructor of such companion classes to
      *  be completed so that OriginalSymbol attachments are pushed to DerivedTypeTrees
      *  in apply/unapply methods.

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

@@ -60,7 +60,7 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
   class NonEmptyFunction(args: List[Tree], body: Tree, val mods: Modifiers) extends Function(args, body)
 
   /** A function created from a wildcard expression
-   *  @param  placeHolderParams  a list of definitions of synthetic parameters
+   *  @param  placeholderParams  a list of definitions of synthetic parameters.
    *  @param  body               the function body where wildcards are replaced by
    *                             references to synthetic parameters.
    */

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

@@ -30,8 +30,8 @@ object CheckRealizable {
   class NotFinal(sym: Symbol)(implicit ctx: Context)
   extends Realizability(i" refers to nonfinal $sym")
 
-  class HasProblemBounds(typ: SingleDenotation)(implicit ctx: Context)
-  extends Realizability(i" has a member $typ with possibly conflicting bounds ${typ.info.bounds.lo} <: ... <: ${typ.info.bounds.hi}")
+  class HasProblemBounds(name: Name, info: Type)(implicit ctx: Context)
+  extends Realizability(i" has a member $name with possibly conflicting bounds ${info.bounds.lo} <: ... <: ${info.bounds.hi}")
 
   class HasProblemBaseArg(typ: Type, argBounds: TypeBounds)(implicit ctx: Context)
   extends Realizability(i" has a base type $typ with possibly conflicting parameter bounds ${argBounds.lo} <: ... <: ${argBounds.hi}")
@@ -96,6 +96,14 @@ class CheckRealizable(implicit ctx: Context) {
       else boundsRealizability(tp).andAlso(memberRealizability(tp))
   }
 
+  private def refinedNames(tp: Type): Set[Name] = tp.dealias match {
+    case tp: RefinedType => refinedNames(tp.parent) + tp.refinedName
+    case tp: AndType => refinedNames(tp.tp1) ++ refinedNames(tp.tp2)
+    case tp: OrType  => refinedNames(tp.tp1) ++ refinedNames(tp.tp2)
+    case tp: TypeProxy => refinedNames(tp.underlying)
+    case _ => Set.empty
+  }
+
   /** `Realizable` if `tp` has good bounds, a `HasProblem...` instance
    *  pointing to a bad bounds member otherwise. "Has good bounds" means:
    *
@@ -107,12 +115,22 @@ class CheckRealizable(implicit ctx: Context) {
    *       also lead to base types with bad bounds).
    */
   private def boundsRealizability(tp: Type) = {
-    val mbrProblems =
+
+    val memberProblems =
       for {
         mbr <- tp.nonClassTypeMembers
         if !(mbr.info.loBound <:< mbr.info.hiBound)
       }
-      yield new HasProblemBounds(mbr)
+      yield new HasProblemBounds(mbr.name, mbr.info)
+
+    val refinementProblems =
+      for {
+        name <- refinedNames(tp)
+        if (name.isTypeName)
+        mbr <- tp.member(name).alternatives
+        if !(mbr.info.loBound <:< mbr.info.hiBound)
+      }
+      yield new HasProblemBounds(name, mbr.info)
 
     def baseTypeProblems(base: Type) = base match {
       case AndType(base1, base2) =>
@@ -126,12 +144,13 @@ class CheckRealizable(implicit ctx: Context) {
     val baseProblems =
       tp.baseClasses.map(_.baseTypeOf(tp)).flatMap(baseTypeProblems)
 
-    (((Realizable: Realizability)
-      /: mbrProblems)(_ andAlso _)
+    ((((Realizable: Realizability)
+      /: memberProblems)(_ andAlso _)
+      /: refinementProblems)(_ andAlso _)
       /: baseProblems)(_ andAlso _)
   }
 
-  /** `Realizable` if all of `tp`'s non-struct fields have realizable types,
+  /** `Realizable` if all of `tp`'s non-strict fields have realizable types,
    *  a `HasProblemField` instance pointing to a bad field otherwise.
    */
   private def memberRealizability(tp: Type) = {

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

@@ -1020,12 +1020,6 @@ object Denotations {
       interval
     }
 
-    /** For ClassDenotations only:
-     *  If caches influenced by parent classes are still valid, the denotation
-     *  itself, otherwise a freshly initialized copy.
-     */
-    def syncWithParents(implicit ctx: Context): SingleDenotation = this
-
     /** Show declaration string; useful for showing declarations
      *  as seen from subclasses.
      */

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

@@ -1648,6 +1648,8 @@ object Types {
       }
 
     final def symbol(implicit ctx: Context): Symbol =
+      // We can rely on checkedPeriod (unlike in the definition of `denot` below)
+      // because SymDenotation#installAfter never changes the symbol
       if (checkedPeriod == ctx.period) lastSymbol else computeSymbol
 
     private def computeSymbol(implicit ctx: Context): Symbol =
@@ -1692,17 +1694,11 @@ object Types {
     /** The denotation currently denoted by this type */
     final def denot(implicit ctx: Context): Denotation = {
       val now = ctx.period
-      val lastd = lastDenotation
-      if (checkedPeriod == now) lastd else denotAt(lastd, now)
-    }
-
-    /** A first fall back to do a somewhat more expensive calculation in case the first
-     *  attempt in `denot` does not yield a denotation.
-     */
-    private def denotAt(lastd: Denotation, now: Period)(implicit ctx: Context): Denotation = {
-      if (checkedPeriod != Nowhere && lastd.validFor.contains(now)) {
+      // Even if checkedPeriod == now we still need to recheck lastDenotation.validFor
+      // as it may have been mutated by SymDenotation#installAfter
+      if (checkedPeriod != Nowhere && lastDenotation.validFor.contains(now)) {
         checkedPeriod = now
-        lastd
+        lastDenotation
       }
       else computeDenot
     }
@@ -3485,10 +3481,9 @@ object Types {
     }
 
     def appliedRef(implicit ctx: Context): Type = {
-      def clsDenot = if (prefix eq cls.owner.thisType) cls.denot else cls.denot.copySymDenotation(info = this)
       if (appliedRefCache == null)
         appliedRefCache =
-          TypeRef(prefix, cls.name, clsDenot).appliedTo(cls.typeParams.map(_.typeRef))
+          TypeRef(prefix, cls).appliedTo(cls.typeParams.map(_.typeRef))
       appliedRefCache
     }
 

compiler/src/dotty/tools/dotc/core/quoted/PickledQuotes.scala

@@ -10,6 +10,8 @@ import dotty.tools.dotc.core.Flags._
 import dotty.tools.dotc.core.StdNames._
 import dotty.tools.dotc.core.NameKinds
 import dotty.tools.dotc.core.Symbols._
+import dotty.tools.dotc.core.Types.Type
+import dotty.tools.dotc.core.tasty.TreePickler.Hole
 import dotty.tools.dotc.core.tasty.{TastyPickler, TastyPrinter, TastyString}
 
 import scala.quoted.Types._
@@ -24,16 +26,21 @@ object PickledQuotes {
   def pickleQuote(tree: Tree)(implicit ctx: Context): scala.runtime.quoted.Unpickler.Pickled = {
     if (ctx.reporter.hasErrors) Nil
     else {
+      assert(!tree.isInstanceOf[Hole]) // Should not be pickled as it represents `'(~x)` which should be optimized to `x`
       val encapsulated = encapsulateQuote(tree)
       val pickled = pickle(encapsulated)
       TastyString.pickle(pickled)
     }
   }
 
   /** Transform the expression into its fully spliced Tree */
-  def quotedExprToTree(expr: quoted.Expr[_])(implicit ctx: Context): Tree = expr match {
+  def quotedExprToTree[T](expr: quoted.Expr[T])(implicit ctx: Context): Tree = expr match {
     case expr: TastyExpr[_] => unpickleExpr(expr)
-    case expr: LiftedExpr[_] => Literal(Constant(expr.value))
+    case expr: LiftedExpr[T] =>
+      expr.value match {
+        case value: Class[_] => ref(defn.Predef_classOf).appliedToType(classToType(value))
+        case value=> Literal(Constant(value))
+      }
     case expr: TreeExpr[Tree] @unchecked => expr.tree
     case expr: FunctionAppliedTo[_, _] =>
       functionAppliedTo(quotedExprToTree(expr.f), quotedExprToTree(expr.x))
@@ -154,4 +161,27 @@ object PickledQuotes {
     }
     Block(x1 :: Nil, rec(f))
   }
+
+  private def classToType(clazz: Class[_])(implicit ctx: Context): Type = {
+    if (clazz.isPrimitive) {
+      if (clazz == classOf[Boolean]) defn.BooleanType
+      else if (clazz == classOf[Byte]) defn.ByteType
+      else if (clazz == classOf[Char]) defn.CharType
+      else if (clazz == classOf[Short]) defn.ShortType
+      else if (clazz == classOf[Int]) defn.IntType
+      else if (clazz == classOf[Long]) defn.LongType
+      else if (clazz == classOf[Float]) defn.FloatType
+      else if (clazz == classOf[Double]) defn.DoubleType
+      else defn.UnitType
+    } else if (clazz.isArray) {
+      defn.ArrayType.appliedTo(classToType(clazz.getComponentType))
+    } else if (clazz.isMemberClass) {
+      val name = clazz.getSimpleName.toTypeName
+      val enclosing = classToType(clazz.getEnclosingClass)
+      if (enclosing.member(name).exists) enclosing.select(name)
+      else {
+        enclosing.classSymbol.companionModule.termRef.select(name)
+      }
+    } else ctx.getClassIfDefined(clazz.getCanonicalName).typeRef
+  }
 }

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

@@ -198,6 +198,7 @@ Standard-Section: "ASTs" TopLevelStat*
                   SCALA2X                             // Imported from Scala2.x
                   DEFAULTparameterized                // Method with default parameters
                   STABLE                              // Method that is assumed to be stable
+                  PARAMsetter                         // A setter without a body named `x_=` where `x` is pickled as a PARAM
                   Annotation
 
   Annotation    = ANNOTATION     Length tycon_Type fullAnnotation_Term
@@ -226,8 +227,8 @@ Standard Section: "Positions" Assoc*
 object TastyFormat {
 
   final val header = Array(0x5C, 0xA1, 0xAB, 0x1F)
-  val MajorVersion = 5
-  val MinorVersion = 1
+  val MajorVersion = 6
+  val MinorVersion = 0
 
   /** Tags used to serialize names */
   class NameTags {
@@ -268,6 +269,7 @@ object TastyFormat {
   // AST tags
   // Cat. 1:    tag
 
+  final val firstSimpleTreeTag = UNITconst
   final val UNITconst = 2
   final val FALSEconst = 3
   final val TRUEconst = 4
@@ -300,6 +302,7 @@ object TastyFormat {
   final val STABLE = 31
   final val MACRO = 32
   final val ERASED = 33
+  final val PARAMsetter = 34
 
   // Cat. 2:    tag Nat
 
@@ -417,15 +420,14 @@ object TastyFormat {
 
   final val HOLE = 255
 
-  final val firstSimpleTreeTag = UNITconst
   final val firstNatTreeTag = SHAREDterm
   final val firstASTTreeTag = THIS
   final val firstNatASTTreeTag = IDENT
   final val firstLengthTreeTag = PACKAGE
 
   /** Useful for debugging */
   def isLegalTag(tag: Int) =
-    firstSimpleTreeTag <= tag && tag <= ERASED ||
+    firstSimpleTreeTag <= tag && tag <= PARAMsetter ||
     firstNatTreeTag <= tag && tag <= SYMBOLconst ||
     firstASTTreeTag <= tag && tag <= SINGLETONtpt ||
     firstNatASTTreeTag <= tag && tag <= NAMEDARG ||
@@ -463,6 +465,7 @@ object TastyFormat {
        | SCALA2X
        | DEFAULTparameterized
        | STABLE
+       | PARAMsetter
        | ANNOTATION
        | PRIVATEqualified
        | PROTECTEDqualified => true
@@ -518,6 +521,7 @@ object TastyFormat {
     case SCALA2X => "SCALA2X"
     case DEFAULTparameterized => "DEFAULTparameterized"
     case STABLE => "STABLE"
+    case PARAMsetter => "PARAMsetter"
 
     case SHAREDterm => "SHAREDterm"
     case SHAREDtype => "SHAREDtype"

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

@@ -601,6 +601,7 @@ class TreePickler(pickler: TastyPickler) {
       if (flags is CaseAccessor) writeByte(CASEaccessor)
       if (flags is DefaultParameterized) writeByte(DEFAULTparameterized)
       if (flags is Stable) writeByte(STABLE)
+      if ((flags is ParamAccessor) && sym.isSetter) writeByte(PARAMsetter)
     } else {
       if (flags is Sealed) writeByte(SEALED)
       if (flags is Abstract) writeByte(ABSTRACT)

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

@@ -251,17 +251,17 @@ class TreeUnpickler(reader: TastyReader,
               val space = readType()
               sname match {
                 case SignedName(name, sig) =>
-                  TermRef(prefix, name, space.decl(name).atSignature(sig))
+                  TermRef(prefix, name, space.decl(name).asSeenFrom(prefix).atSignature(sig))
                 case name =>
-                  TermRef(prefix, name, space.decl(name))
+                  TermRef(prefix, name, space.decl(name).asSeenFrom(prefix))
               }
             case TYPEREFin =>
               val name = readName().toTypeName
               val prefix = readType()
               val space = readType()
               space.decl(name) match {
                 case symd: SymDenotation if prefix.isArgPrefixOf(symd.symbol) => TypeRef(prefix, symd.symbol)
-                case _ => TypeRef(prefix, name, space.decl(name))
+                case _ => TypeRef(prefix, name, space.decl(name).asSeenFrom(prefix))
               }
             case REFINEDtype =>
               var name: Name = readName()
@@ -424,7 +424,11 @@ class TreeUnpickler(reader: TastyReader,
         flags = flags | (if (tag == VALDEF) ModuleValCreationFlags else ModuleClassCreationFlags)
       if (ctx.owner.isClass) {
         if (tag == TYPEPARAM) flags |= Param
-        else if (tag == PARAM) flags |= ParamAccessor
+        else if (tag == PARAM) {
+          flags |= ParamAccessor
+          if (!rhsIsEmpty) // param alias
+            flags |= Method
+        }
       }
       else if (isParamTag(tag)) flags |= Param
       flags
@@ -585,6 +589,8 @@ class TreeUnpickler(reader: TastyReader,
           case SCALA2X => addFlag(Scala2x)
           case DEFAULTparameterized => addFlag(DefaultParameterized)
           case STABLE => addFlag(Stable)
+          case PARAMsetter =>
+            addFlag(ParamAccessor)
           case PRIVATEqualified =>
             readByte()
             privateWithin = readType().typeSymbol
@@ -728,11 +734,6 @@ class TreeUnpickler(reader: TastyReader,
               vparamss.nestedMap(_.symbol), name == nme.CONSTRUCTOR)
           val resType = ctx.effectiveResultType(sym, typeParams, tpt.tpe)
           sym.info = ctx.methodType(typeParams, valueParamss, resType)
-          if (sym.isSetter && sym.accessedFieldOrGetter.is(ParamAccessor)) {
-            // reconstitute ParamAccessor flag of setters for var parameters, which is not pickled
-            sym.setFlag(ParamAccessor)
-            sym.resetFlag(Deferred)
-          }
           DefDef(tparams, vparamss, tpt)
         case VALDEF =>
           val tpt = readTpt()(localCtx)
@@ -775,7 +776,6 @@ class TreeUnpickler(reader: TastyReader,
             ValDef(tpt)
           }
           else {
-            sym.setFlag(Method)
             sym.info = ExprType(tpt.tpe)
             pickling.println(i"reading param alias $name -> $currentAddr")
             DefDef(Nil, Nil, tpt)
@@ -1142,10 +1142,14 @@ class TreeUnpickler(reader: TastyReader,
       val splice = splices(idx)
       val reifiedArgs = args.map(arg => if (arg.isTerm) new TreeExpr(arg) else new TreeType(arg))
       if (isType) {
-        val quotedType = splice.asInstanceOf[Seq[Any] => quoted.Type[_]](reifiedArgs)
+        val quotedType =
+          if (reifiedArgs.isEmpty) splice.asInstanceOf[quoted.Type[_]]
+          else splice.asInstanceOf[Seq[Any] => quoted.Type[_]](reifiedArgs)
         PickledQuotes.quotedTypeToTree(quotedType)
       } else {
-        val quotedExpr = splice.asInstanceOf[Seq[Any] => quoted.Expr[_]](reifiedArgs)
+        val quotedExpr =
+          if (reifiedArgs.isEmpty) splice.asInstanceOf[quoted.Expr[_]]
+          else splice.asInstanceOf[Seq[Any] => quoted.Expr[_]](reifiedArgs)
         PickledQuotes.quotedExprToTree(quotedExpr)
       }
     }