Native applied types

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

@@ -105,7 +105,7 @@ class Run(comp: Compiler, ictx: Context) {
     compileUnits()(ctx)
   }
 
-  protected def compileUnits()(implicit ctx: Context) = Stats.monitorHeartBeat {
+  protected def compileUnits()(implicit ctx: Context) = Stats.maybeMonitored {
     ctx.checkSingleThreaded()
 
     // If testing pickler, make sure to stop after pickling phase:
@@ -118,17 +118,18 @@ class Run(comp: Compiler, ictx: Context) {
     ctx.usePhases(phases)
     var lastPrintedTree: PrintedTree = NoPrintedTree
     for (phase <- ctx.allPhases)
-      if (phase.isRunnable) {
-        val start = System.currentTimeMillis
-        units = phase.runOn(units)
-        if (ctx.settings.Xprint.value.containsPhase(phase)) {
-          for (unit <- units) {
-            lastPrintedTree =
-              printTree(lastPrintedTree)(ctx.fresh.setPhase(phase.next).setCompilationUnit(unit))
+      if (phase.isRunnable)
+        Stats.trackTime(s"$phase ms ") {
+          val start = System.currentTimeMillis
+          units = phase.runOn(units)
+          if (ctx.settings.Xprint.value.containsPhase(phase)) {
+            for (unit <- units) {
+              lastPrintedTree =
+                printTree(lastPrintedTree)(ctx.fresh.setPhase(phase.next).setCompilationUnit(unit))
+            }
           }
+          ctx.informTime(s"$phase ", start)
         }
-        ctx.informTime(s"$phase ", start)
-      }
     if (!ctx.reporter.hasErrors) Rewrites.writeBack()
     for (unit <- units)
       Stats.record("retained typed trees at end", unit.tpdTree.treeSize)

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

@@ -5,7 +5,7 @@ package ast
 import core._
 import util.Positions._, Types._, Contexts._, Constants._, Names._, NameOps._, Flags._
 import SymDenotations._, Symbols._, StdNames._, Annotations._, Trees._
-import Decorators._
+import Decorators._, transform.SymUtils._
 import NameKinds.{UniqueName, EvidenceParamName, DefaultGetterName}
 import language.higherKinds
 import typer.FrontEnd
@@ -70,7 +70,7 @@ object desugar {
         def apply(tp: Type) = tp match {
           case tp: NamedType if tp.symbol.exists && (tp.symbol.owner eq originalOwner) =>
             val defctx = ctx.outersIterator.dropWhile(_.scope eq ctx.scope).next()
-            var local = defctx.denotNamed(tp.name).suchThat(_ is ParamOrAccessor).symbol
+            var local = defctx.denotNamed(tp.name).suchThat(_.isParamOrAccessor).symbol
             if (local.exists) (defctx.owner.thisType select local).dealias
             else {
               def msg =
@@ -238,23 +238,6 @@ object desugar {
         Nil
     }
 
-  /** Fill in empty type bounds with Nothing/Any. Expand private local type parameters as follows:
-   *
-   *     class C[v T]
-   * ==>
-   *     class C { type v C$T; type v T = C$T }
-   */
-  def typeDef(tdef: TypeDef)(implicit ctx: Context): Tree = {
-    if (tdef.mods is PrivateLocalParam) {
-      val tparam = cpy.TypeDef(tdef)(name = tdef.name.expandedName(ctx.owner))
-        .withMods(tdef.mods &~ PrivateLocal)
-      val alias = cpy.TypeDef(tdef)(rhs = refOfDef(tparam))
-        .withMods(tdef.mods & VarianceFlags | PrivateLocalParamAccessor | Synthetic)
-      Thicket(tparam, alias)
-    }
-    else tdef
-  }
-
   @sharable private val synthetic = Modifiers(Synthetic)
 
   private def toDefParam(tparam: TypeDef): TypeDef =
@@ -696,7 +679,7 @@ object desugar {
 
   def defTree(tree: Tree)(implicit ctx: Context): Tree = tree match {
     case tree: ValDef => valDef(tree)
-    case tree: TypeDef => if (tree.isClassDef) classDef(tree) else typeDef(tree)
+    case tree: TypeDef => if (tree.isClassDef) classDef(tree) else tree
     case tree: DefDef => defDef(tree)
     case tree: ModuleDef => moduleDef(tree)
     case tree: PatDef => patDef(tree)
@@ -1132,7 +1115,7 @@ object desugar {
    */
   def refinedTypeToClass(parent: tpd.Tree, refinements: List[Tree])(implicit ctx: Context): TypeDef = {
     def stripToCore(tp: Type): List[Type] = tp match {
-      case tp: RefinedType if tp.argInfos.nonEmpty => tp :: Nil // parameterized class type
+      case tp: AppliedType => tp :: Nil
       case tp: TypeRef if tp.symbol.isClass => tp :: Nil     // monomorphic class type
       case tp: TypeProxy => stripToCore(tp.underlying)
       case AndType(tp1, tp2) => stripToCore(tp1) ::: stripToCore(tp2)

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

@@ -213,8 +213,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     ta.assignType(untpd.TypeDef(sym.name, TypeTree(sym.info)), sym)
 
   def ClassDef(cls: ClassSymbol, constr: DefDef, body: List[Tree], superArgs: List[Tree] = Nil)(implicit ctx: Context): TypeDef = {
-    val firstParentRef :: otherParentRefs = cls.info.parents
-    val firstParent = cls.typeRef.baseTypeWithArgs(firstParentRef.symbol)
+    val firstParent :: otherParents = cls.info.parents
     val superRef =
       if (cls is Trait) TypeTree(firstParent)
       else {
@@ -229,7 +228,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
         val constr = firstParent.decl(nme.CONSTRUCTOR).suchThat(constr => isApplicable(constr.info))
         New(firstParent, constr.symbol.asTerm, superArgs)
       }
-    val parents = superRef :: otherParentRefs.map(TypeTree(_))
+    val parents = superRef :: otherParents.map(TypeTree(_))
 
     val selfType =
       if (cls.classInfo.selfInfo ne NoType) ValDef(ctx.newSelfSym(cls))
@@ -305,7 +304,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
         true
       case pre: ThisType =>
         pre.cls.isStaticOwner ||
-          tp.symbol.is(ParamOrAccessor) && !pre.cls.is(Trait) && ctx.owner.enclosingClass == pre.cls
+          tp.symbol.isParamOrAccessor && !pre.cls.is(Trait) && ctx.owner.enclosingClass == pre.cls
           // was ctx.owner.enclosingClass.derivesFrom(pre.cls) which was not tight enough
           // and was spuriously triggered in case inner class would inherit from outer one
           // eg anonymous TypeMap inside TypeMap.andThen
@@ -381,7 +380,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
   /** new C(args), calling given constructor `constr` of C */
   def New(tp: Type, constr: TermSymbol, args: List[Tree])(implicit ctx: Context): Apply = {
     val targs = tp.argTypes
-    val tycon = tp.withoutArgs(targs)
+    val tycon = tp.typeConstructor
     New(tycon)
       .select(TermRef.withSig(tycon, constr))
       .appliedToTypes(targs)
@@ -698,8 +697,10 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
      */
     def select(sym: Symbol)(implicit ctx: Context): Select = {
       val tp =
-        if (sym.isType)
+        if (sym.isType) {
+          assert(!sym.is(TypeParam))
           TypeRef(tree.tpe, sym.name.asTypeName)
+        }
         else
           TermRef.withSigAndDenot(tree.tpe, sym.name.asTermName,
             sym.signature, sym.denot.asSeenFrom(tree.tpe))

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

@@ -296,9 +296,9 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
         (tycon, targs)
       case TypedSplice(AppliedTypeTree(tycon, targs)) =>
         (TypedSplice(tycon), targs map (TypedSplice(_)))
-      case TypedSplice(tpt1: Tree) =>
+      case TypedSplice(tpt1: tpd.Tree) =>
+        val tycon = tpt1.tpe.typeConstructor
         val argTypes = tpt1.tpe.argTypesLo
-        val tycon = tpt1.tpe.withoutArgs(argTypes)
         def wrap(tpe: Type) = TypeTree(tpe) withPos tpt.pos
         (wrap(tycon), argTypes map wrap)
       case _ =>

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

@@ -84,19 +84,12 @@ object Config {
   /** If this flag is set, take the fast path when comparing same-named type-aliases and types */
   final val fastPathForRefinedSubtype = true
 
-  /** If this flag is set, `TypeOps.normalizeToClassRefs` will insert forwarders
-   *  for type parameters of base classes. This is an optimization, which avoids
-   *  long alias chains. We should  not rely on the optimization, though. So changing
-   *  the flag to false can be used for checking that everything works OK without it.
-   */
-  final val forwardTypeParams = true
-
-  /** If this flag is set, and we compute `T1 { X = S1 }` & `T2 { X = S2 }` as a new
-   *  upper bound of a constrained parameter, try to align the refinements by computing
+  /** If this flag is set, and we compute `T1[X1]` & `T2[X2]` as a new
+   *  upper bound of a constrained parameter, try to align the arguments by computing
    *  `S1 =:= S2` (which might instantiate type parameters).
    *  This rule is contentious because it cuts the constraint set.
    *
-   *  For more info, see the comment in `TypeComparer#distributeAnd`.
+   *  For more info, see the comment in `TypeComparer#glbArgs`.
    */
   final val alignArgsInAnd = true
 
@@ -113,6 +106,13 @@ object Config {
    */
   final val checkTypeRefCycles = false
 
+  /** If this flag is set, it is checked that class type parameters are
+   *  only references with NoPrefix or ThisTypes as prefixes. This option
+   *  is usally disabled, because there are still some legitimate cases where
+   *  this can arise (e.g. for pos/Map.scala, in LambdaType.integrate).
+   */
+  final val checkTypeParamRefs = false
+
   /** The recursion depth for showing a summarized string */
   final val summarizeDepth = 2
 

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

@@ -67,7 +67,6 @@ class ScalaSettings extends Settings.SettingGroup {
   val Ycheck = PhasesSetting("-Ycheck", "Check the tree at the end of")
   val YcheckMods = BooleanSetting("-Ycheck-mods", "Check that symbols and their defining trees have modifiers in sync")
   val debug = BooleanSetting("-Ydebug", "Increase the quantity of debugging output.")
-  val debugAlias = BooleanSetting("-Ydebug-alias", "Never follow alias when printing types")
   val debugTrace = BooleanSetting("-Ydebug-trace", "Trace core operations")
   val debugFlags = BooleanSetting("-Ydebug-flags", "Print all flags of definitions")
   val debugNames = BooleanSetting("-Ydebug-names", "Show internal representation of names")
@@ -87,7 +86,8 @@ class ScalaSettings extends Settings.SettingGroup {
   val YmethodInfer = BooleanSetting("-Yinfer-argument-types", "Infer types for arguments of overriden methods.")
   val YtraceContextCreation = BooleanSetting("-Ytrace-context-creation", "Store stack trace of context creations.")
   val YshowSuppressedErrors = BooleanSetting("-Yshow-suppressed-errors", "Also show follow-on errors and warnings that are normally supressed.")
-  val Yheartbeat = BooleanSetting("-Yheartbeat", "show heartbeat stack trace of compiler operations.")
+  val YdetailedStats = BooleanSetting("-Ydetailed-stats", "show detailed internal compiler stats (needs Stats.enabled to be set to true).")
+  val Yheartbeat = BooleanSetting("-Ydetailed-stats", "show heartbeat stack trace of compiler operations (needs Stats.enabled to be set to true).")
   val Yprintpos = BooleanSetting("-Yprintpos", "show tree positions.")
   val YnoDeepSubtypes = BooleanSetting("-Yno-deep-subtypes", "throw an exception on deep subtyping call stacks.")
   val YnoPatmatOpt = BooleanSetting("-Yno-patmat-opt", "disable all pattern matching optimizations.")

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

@@ -103,7 +103,7 @@ object Annotations {
 
     private def resolveConstructor(atp: Type, args:List[Tree])(implicit ctx: Context): Tree = {
       val targs = atp.argTypes
-      tpd.applyOverloaded(New(atp withoutArgs targs), nme.CONSTRUCTOR, args, targs, atp, isAnnotConstructor = true)
+      tpd.applyOverloaded(New(atp.typeConstructor), nme.CONSTRUCTOR, args, targs, atp, isAnnotConstructor = true)
     }
 
     def applyResolve(atp: Type, args: List[Tree])(implicit ctx: Context): Annotation = {

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

@@ -33,6 +33,12 @@ object CheckRealizable {
   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 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}")
+
+  class HasProblemBase(base1: Type, base2: Type)(implicit ctx: Context)
+  extends Realizability(i" has conflicting base types $base1 and $base2")
+
   class HasProblemField(fld: SingleDenotation, problem: Realizability)(implicit ctx: Context)
   extends Realizability(i" has a member $fld which is not a legal path\n since ${fld.symbol.name}: ${fld.info}${problem.msg}")
 
@@ -89,18 +95,36 @@ class CheckRealizable(implicit ctx: Context) {
       else boundsRealizability(tp).andAlso(memberRealizability(tp))
   }
 
-  /** `Realizable` if `tp` has good bounds, a `HasProblemBounds` instance
-   *  pointing to a bad bounds member otherwise.
+  /** `Realizable` if `tp` has good bounds, a `HasProblem...` instance
+   *  pointing to a bad bounds member otherwise. "Has good bounds" means:
+   *
+   *    - all type members have good bounds
+   *    - all base types are class types, and if their arguments are wildcards
+   *      they have good bounds.
    */
   private def boundsRealizability(tp: Type) = {
-    def hasBadBounds(mbr: SingleDenotation) = {
-      val bounds = mbr.info.bounds
-      !(bounds.lo <:< bounds.hi)
-    }
-    tp.nonClassTypeMembers.find(hasBadBounds) match {
-      case Some(mbr) => new HasProblemBounds(mbr)
-      case _ => Realizable
+    val mbrProblems =
+      for {
+        mbr <- tp.nonClassTypeMembers
+        if !(mbr.info.loBound <:< mbr.info.hiBound)
+      }
+      yield new HasProblemBounds(mbr)
+
+    def baseTypeProblems(base: Type) = base match {
+      case AndType(base1, base2) =>
+        new HasProblemBase(base1, base2) :: Nil
+      case base =>
+        base.argInfos.collect {
+          case bounds @ TypeBounds(lo, hi) if !(lo <:< hi) =>
+            new HasProblemBaseArg(base, bounds)
+        }
     }
+    val baseProblems =
+      tp.baseClasses.map(_.baseTypeOf(tp)).flatMap(baseTypeProblems)
+
+    (((Realizable: Realizability)
+      /: mbrProblems)(_ andAlso _)
+      /: baseProblems)(_ andAlso _)
   }
 
   /** `Realizable` if all of `tp`'s non-struct fields have realizable types,

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

@@ -6,7 +6,7 @@ import Types._, Contexts._, Symbols._
 import Decorators._
 import config.Config
 import config.Printers.{constr, typr}
-import TypeApplications.EtaExpansion
+import TypeApplications.{EtaExpansion, TypeParamInfo}
 import collection.mutable
 
 /** Methods for adding constraints and solving them.
@@ -194,9 +194,15 @@ trait ConstraintHandling {
   final def approximation(param: TypeParamRef, fromBelow: Boolean): Type = {
     val avoidParam = new TypeMap {
       override def stopAtStatic = true
+      def avoidInArg(arg: Type, formal: TypeParamInfo): Type =
+        if (param.occursIn(arg)) TypeBounds.empty else arg
       def apply(tp: Type) = mapOver {
         tp match {
-          case tp: RefinedType if param occursIn tp.refinedInfo => tp.parent
+          case tp @ AppliedType(tycon, args) =>
+            tp.derivedAppliedType(tycon,
+              args.zipWithConserve(tycon.typeParams)(avoidInArg))
+          case tp: RefinedType if param occursIn tp.refinedInfo =>
+            tp.parent
           case tp: WildcardType =>
             val bounds = tp.optBounds.orElse(TypeBounds.empty).bounds
             // Try to instantiate the wildcard to a type that is known to conform to it.
@@ -306,7 +312,12 @@ trait ConstraintHandling {
   /** The current bounds of type parameter `param` */
   final def bounds(param: TypeParamRef): TypeBounds = {
     val e = constraint.entry(param)
-    if (e.exists) e.bounds else param.binder.paramInfos(param.paramNum)
+    if (e.exists) e.bounds
+    else {
+      val pinfos = param.binder.paramInfos
+      if (pinfos != null) pinfos(param.paramNum) // pinfos == null happens in pos/i536.scala
+      else TypeBounds.empty
+    }
   }
 
   /** Add type lambda `tl`, possibly with type variables `tvars`, to current constraint
@@ -318,7 +329,7 @@ trait ConstraintHandling {
       checkPropagated(i"initialized $tl") {
         constraint = constraint.add(tl, tvars)
         tl.paramNames.indices.forall { i =>
-          val param = TypeParamRef(tl, i)
+          val param = tl.paramRefs(i)
           val bounds = constraint.nonParamBounds(param)
           val lower = constraint.lower(param)
           val upper = constraint.upper(param)
@@ -376,7 +387,12 @@ trait ConstraintHandling {
         else tp
 
       def addParamBound(bound: TypeParamRef) =
-        if (fromBelow) addLess(bound, param) else addLess(param, bound)
+        constraint.entry(param) match {
+          case _: TypeBounds =>
+            if (fromBelow) addLess(bound, param) else addLess(param, bound)
+          case tp =>
+            if (fromBelow) isSubType(bound, tp) else isSubType(tp, bound)
+        }
 
       /** Drop all constrained parameters that occur at the toplevel in `bound` and
        *  handle them by `addLess` calls.