Merge pull request #147 from dotty-staging/transform/variance

transform/variance

Author: odersky

src/dotty/tools/dotc/ast/CheckTrees.scala renamed to src/dotty/tools/dotc/ast/CheckTrees.scala.disabled

@@ -191,17 +191,18 @@ object desugar {
 
   /** Fill in empty type bounds with Nothing/Any. Expand private local type parameters as follows:
    *
-   *     class C[T]
+   *     class C[v T]
    * ==>
-   *     class C { type C$T; type T = C$T }
+   *     class C { type v C$T; type v T = C$T }
    */
   def typeDef(tdef: TypeDef)(implicit ctx: Context): Tree = {
     val TypeDef(mods, name, rhs) = tdef
     if (mods is PrivateLocalParam) {
       val tparam = cpy.TypeDef(tdef,
         mods &~ PrivateLocal | ExpandedName, name.expandedName(ctx.owner), rhs, tdef.tparams)
       val alias = cpy.TypeDef(tdef,
-        Modifiers(PrivateLocalParamAccessor | Synthetic), name, refOfDef(tparam))
+        Modifiers(PrivateLocalParamAccessor | Synthetic | mods.flags & VarianceFlags),
+                  name, refOfDef(tparam))
       Thicket(tparam, alias)
     }
     else cpy.TypeDef(tdef, mods, name, rhs, tdef.tparams)
@@ -274,7 +275,13 @@ object desugar {
     //     def _1 = this.p1
     //     ...
     //     def _N = this.pN
-    //     def copy(p1: T1 = p1, ..., pN: TN = pN)(moreParams) = new C[...](p1, ..., pN)(moreParams)
+    //     def copy(p1: T1 = p1: @uncheckedVariance, ...,
+    //              pN: TN = pN: @uncheckedVariance)(moreParams) =
+    //       new C[...](p1, ..., pN)(moreParams)
+    //
+    // Note: copy default parameters need @uncheckedVariance; see
+    // neg/t1843-variances.scala for a test case. The test would give
+    // two errors without @uncheckedVariance, one of them spurious.
     val caseClassMeths =
       if (mods is Case) {
         def syntheticProperty(name: TermName, rhs: Tree) =
@@ -289,8 +296,10 @@ object desugar {
         val copyMeths =
           if (mods is Abstract) Nil
           else {
+            def copyDefault(vparam: ValDef) =
+              makeAnnotated(defn.UncheckedVarianceAnnot, refOfDef(vparam))
             val copyFirstParams = derivedVparamss.head.map(vparam =>
-              cpy.ValDef(vparam, vparam.mods, vparam.name, vparam.tpt, refOfDef(vparam)))
+              cpy.ValDef(vparam, vparam.mods, vparam.name, vparam.tpt, copyDefault(vparam)))
             val copyRestParamss = derivedVparamss.tail.nestedMap(vparam =>
               cpy.ValDef(vparam, vparam.mods, vparam.name, vparam.tpt, EmptyTree))
             DefDef(synthetic, nme.copy, derivedTparams, copyFirstParams :: copyRestParamss, TypeTree(), creatorExpr) :: Nil

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

@@ -6,7 +6,7 @@ import core._
 import dotty.tools.dotc.transform.TypeUtils
 import util.Positions._, Types._, Contexts._, Constants._, Names._, Flags._
 import SymDenotations._, Symbols._, StdNames._, Annotations._, Trees._, Symbols._
-import CheckTrees._, Denotations._, Decorators._
+import Denotations._, Decorators._
 import config.Printers._
 import typer.ErrorReporting._
 
@@ -134,7 +134,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     TypeTree(original.tpe, original)
 
   def TypeTree(tp: Type, original: Tree = EmptyTree)(implicit ctx: Context): TypeTree =
-    untpd.TypeTree(original).withType(tp).checked
+    untpd.TypeTree(original).withType(tp)
 
   def SingletonTypeTree(ref: Tree)(implicit ctx: Context): SingletonTypeTree =
     ta.assignType(untpd.SingletonTypeTree(ref), ref)
@@ -237,7 +237,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     val localDummy = ((NoSymbol: Symbol) /: body)(findLocalDummy)
       .orElse(ctx.newLocalDummy(cls))
     val impl = untpd.Template(constr, parents, selfType, newTypeParams ++ body)
-      .withType(localDummy.termRef).checked
+      .withType(localDummy.termRef)
     ta.assignType(untpd.TypeDef(Modifiers(cls), cls.name, impl), cls)
   }
 
@@ -354,11 +354,6 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
       case _ => false
     }
 
-    def checked(implicit ctx: Context): ThisTree = {
-      if (ctx.settings.YcheckTypedTrees.value) checkType(tree)
-      tree
-    }
-
     def shallowFold[T](z: T)(op: (T, tpd.Tree) => T) =
       new ShallowFolder(op).apply(z, tree)
 

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

@@ -196,7 +196,6 @@ class Definitions {
     lazy val Array_update                = ctx.requiredMethod(ArrayClass, nme.update)
     lazy val Array_length                = ctx.requiredMethod(ArrayClass, nme.length)
     lazy val Array_clone                 = ctx.requiredMethod(ArrayClass, nme.clone_)
-  lazy val uncheckedStableClass: ClassSymbol = ctx.requiredClass("scala.annotation.unchecked.uncheckedStable")
 
   lazy val UnitClass = valueClassSymbol("scala.Unit", BoxedUnitClass, java.lang.Void.TYPE, UnitEnc)
   lazy val BooleanClass = valueClassSymbol("scala.Boolean", BoxedBooleanClass, java.lang.Boolean.TYPE, BooleanEnc)
@@ -296,6 +295,8 @@ class Definitions {
   lazy val AnnotationDefaultAnnot = ctx.requiredClass("dotty.annotation.internal.AnnotationDefault")
   lazy val ThrowsAnnot = ctx.requiredClass("scala.throws")
   lazy val UncheckedAnnot = ctx.requiredClass("scala.unchecked")
+  lazy val UncheckedStableAnnot = ctx.requiredClass("scala.annotation.unchecked.uncheckedStable")
+  lazy val UncheckedVarianceAnnot = ctx.requiredClass("scala.annotation.unchecked.uncheckedVariance")
   lazy val VolatileAnnot = ctx.requiredClass("scala.volatile")
 
   // convenient one-parameter method types

src/dotty/tools/dotc/core/Definitions.scala

@@ -619,7 +619,7 @@ object Denotations {
       throw new StaleSymbol(msg)
     }
 
-    /** The period (interval of phases) for which there exists 
+    /** The period (interval of phases) for which there exists
      *  a valid denotation in this flock.
      */
     def coveredInterval(implicit ctx: Context): Period = {
@@ -641,11 +641,15 @@ object Denotations {
      */
     def syncWithParents(implicit ctx: Context): SingleDenotation = this
 
+    /** Show declaration string; useful for showing declarations
+     *  as seen from subclasses.
+     */
+    def showDcl(implicit ctx: Context): String = ctx.dclText(this).show
+
     override def toString =
       if (symbol == NoSymbol) symbol.toString
       else s"<SingleDenotation of type $infoOrCompleter>"
 
-
     def definedPeriodsString: String = {
       var sb = new StringBuilder()
       var cur = this

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

@@ -500,6 +500,9 @@ object Flags {
   /** A parameter or parameter accessor */
   final val ParamOrAccessor = Param | ParamAccessor
 
+  /** A type parameter or type parameter accessor */
+  final val TypeParamOrAccessor = TypeParam | TypeParamAccessor
+
   /** A covariant type parameter instance */
   final val LocalCovariant = allOf(Local, Covariant)
 
@@ -521,6 +524,9 @@ object Flags {
   /** A Java companion object */
   final val JavaModule = allOf(JavaDefined, Module)
 
+  /** A Java companion object */
+  final val JavaProtected = allOf(JavaDefined, Protected)
+
   /** Labeled private[this] */
   final val PrivateLocal = allOf(Private, Local)
 

src/dotty/tools/dotc/core/Flags.scala

@@ -73,6 +73,7 @@ object NameOps {
     def isModuleClassName = name endsWith MODULE_SUFFIX
     def isImportName = name startsWith IMPORT
     def isInheritedName = name.length > 0 && name.head == '(' && name.startsWith(nme.INHERITED)
+    def isDefaultGetterName = name.isTermName && name.asTermName.defaultGetterIndex >= 0
 
     def isModuleVarName(name: Name): Boolean =
       name.stripAnonNumberSuffix endsWith MODULE_VAR_SUFFIX
@@ -251,9 +252,12 @@ object NameOps {
 
     /** If this is a default getter, its index (starting from 0), else -1 */
     def defaultGetterIndex: Int = {
-      val p = name.indexOfSlice(DEFAULT_GETTER)
-      if (p >= 0) name.drop(p + DEFAULT_GETTER.length).toString.toInt - 1
-      else -1
+      var i = name.length
+      while (i > 0 && name(i - 1).isDigit) i -= 1
+      if (i > 0 && i < name.length && name.take(i).endsWith(DEFAULT_GETTER))
+        name.drop(i).toString.toInt - 1
+      else
+        -1
     }
 
     /** The name of an accessor for protected symbols. */

src/dotty/tools/dotc/core/NameOps.scala

@@ -402,7 +402,7 @@ object SymDenotations {
     final def isStable(implicit ctx: Context) = {
       val isUnstable =
         (this is UnstableValue) ||
-        ctx.isVolatile(info) && !hasAnnotation(defn.uncheckedStableClass)
+        ctx.isVolatile(info) && !hasAnnotation(defn.UncheckedStableAnnot)
       (this is Stable) || isType || {
         if (isUnstable) false
         else { setFlag(Stable); true }
@@ -589,12 +589,22 @@ object SymDenotations {
         NoSymbol
     }
 
-    /** The field accessed by this getter or setter */
-    def accessedField(implicit ctx: Context): Symbol = {
+    /** The field accessed by this getter or setter, or if it does not exist, the getter */
+    def accessedFieldOrGetter(implicit ctx: Context): Symbol = {
       val fieldName = if (isSetter) name.asTermName.setterToGetter else name
-      owner.info.decl(fieldName).suchThat(d => !(d is Method)).symbol
+      val d = owner.info.decl(fieldName)
+      val field = d.suchThat(!_.is(Method)).symbol
+      def getter = d.suchThat(_.info.isParameterless).symbol
+      field orElse getter
     }
 
+    /** The field accessed by a getter or setter, or
+     *  if it does not exists, the getter of a setter, or
+     *  if that does not exist the symbol itself.
+     */
+    def underlyingSymbol(implicit ctx: Context): Symbol =
+      if (is(Accessor)) accessedFieldOrGetter orElse symbol else symbol
+
     /** The chain of owners of this denotation, starting with the denoting symbol itself */
     final def ownersIterator(implicit ctx: Context) = new Iterator[Symbol] {
       private[this] var current = symbol
@@ -723,17 +733,29 @@ object SymDenotations {
       denot.symbol
     }
 
+    /** If false, this symbol cannot possibly participate in an override,
+     *  either as overrider or overridee.
+     */
+    final def canMatchInheritedSymbols(implicit ctx: Context): Boolean =
+      maybeOwner.isClass && !isConstructor && !is(Private)
+
     /** The symbol, in class `inClass`, that is overridden by this denotation. */
     final def overriddenSymbol(inClass: ClassSymbol)(implicit ctx: Context): Symbol =
-      if ((this is Private) && (owner ne inClass)) NoSymbol
+      if (!canMatchInheritedSymbols && (owner ne inClass)) NoSymbol
       else matchingSymbol(inClass, owner.thisType)
 
     /** All symbols overriden by this denotation. */
     final def allOverriddenSymbols(implicit ctx: Context): Iterator[Symbol] =
-      if (exists && owner.isClass)
-        owner.info.baseClasses.tail.iterator map overriddenSymbol filter (_.exists)
-      else
-        Iterator.empty
+      if (!canMatchInheritedSymbols) Iterator.empty
+      else overriddenFromType(owner.info)
+
+    /** Returns all all matching symbols defined in parents of the selftype. */
+    final def extendedOverriddenSymbols(implicit ctx: Context): Iterator[Symbol] =
+      if (!canMatchInheritedSymbols) Iterator.empty
+      else overriddenFromType(owner.asClass.classInfo.selfType)
+
+    private def overriddenFromType(tp: Type)(implicit ctx: Context): Iterator[Symbol] =
+      tp.baseClasses.tail.iterator map overriddenSymbol filter (_.exists)
 
     /** The symbol overriding this symbol in given subclass `ofclazz`.
      *
@@ -743,17 +765,6 @@ object SymDenotations {
       if (canMatchInheritedSymbols) matchingSymbol(inClass, inClass.thisType)
       else NoSymbol
 
-    /** If false, this symbol cannot possibly participate in an override,
-     *  either as overrider or overridee. For internal use; you should consult
-     *  with isOverridingSymbol. This is used by isOverridingSymbol to escape
-     *  the recursive knot.
-     */
-    private def canMatchInheritedSymbols = (
-         owner.isClass
-      && !this.isClass
-      && !this.isConstructor
-    )
-
     /** The symbol accessed by a super in the definition of this symbol when
      *  seen from class `base`. This symbol is always concrete.
      *  pre: `this.owner` is in the base class sequence of `base`.

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

@@ -2203,6 +2203,7 @@ object Types {
     override def variance = 1
     override def toString = "Co" + super.toString
   }
+
   final class ContraTypeBounds(lo: Type, hi: Type, hc: Int) extends CachedTypeBounds(lo, hi, hc) {
     override def variance = -1
     override def toString = "Contra" + super.toString

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

@@ -2,7 +2,7 @@ package dotty.tools.dotc
 package printing
 
 import core._
-import Texts._, Types._, Flags._, Names._, Symbols._, NameOps._, Constants._
+import Texts._, Types._, Flags._, Names._, Symbols._, NameOps._, Constants._, Denotations._
 import Contexts.Context, Scopes.Scope, Denotations.Denotation, Annotations.Annotation
 import StdNames.nme
 import ast.Trees._, ast.untpd
@@ -321,9 +321,13 @@ class PlainPrinter(_ctx: Context) extends Printer {
 
   def annotsText(sym: Symbol): Text = Text(sym.annotations.map(toText))
 
-  def dclText(sym: Symbol): Text =
+  def dclText(sym: Symbol): Text = dclTextWithInfo(sym, sym.unforcedInfo)
+
+  def dclText(d: SingleDenotation): Text = dclTextWithInfo(d.symbol, Some(d.info))
+
+  private def dclTextWithInfo(sym: Symbol, info: Option[Type]): Text =
     (toTextFlags(sym) ~~ keyString(sym) ~~
-      (varianceString(sym) ~ nameString(sym)) ~ toTextRHS(sym.unforcedInfo)).close
+      (varianceString(sym) ~ nameString(sym)) ~ toTextRHS(info)).close
 
   def toText(sym: Symbol): Text =
     (kindString(sym) ~~ {

src/dotty/tools/dotc/printing/PlainPrinter.scala

@@ -4,7 +4,7 @@ package printing
 import core._
 import Texts._, ast.Trees._
 import Types.Type, Symbols.Symbol, Contexts.Context, Scopes.Scope, Constants.Constant,
-       Names.Name, Denotations.Denotation, Annotations.Annotation
+       Names.Name, Denotations._, Annotations.Annotation
 
 /** The base class of all printers
  */
@@ -59,6 +59,9 @@ abstract class Printer {
   /** Textual representation of symbol's declaration */
   def dclText(sym: Symbol): Text
 
+  /** Textual representation of single denotation's declaration */
+  def dclText(sd: SingleDenotation): Text
+
   /** If symbol's owner is a printable class C, the text "in C", otherwise "" */
   def locationText(sym: Symbol): Text
 

src/dotty/tools/dotc/printing/Printer.scala

@@ -133,7 +133,10 @@ object Erasure {
 
     /** Generate a synthetic cast operation from tree.tpe to pt.
      */
-    def cast(tree: Tree, pt: Type)(implicit ctx: Context): Tree =
+    def cast(tree: Tree, pt: Type)(implicit ctx: Context): Tree = {
+      // TODO: The commented out assertion fails for tailcall/t6574.scala
+      //       Fix the problem and enable the assertion.
+      // assert(!pt.isInstanceOf[SingletonType], pt)
       if (pt isRef defn.UnitClass) unbox(tree, pt)
       else (tree.tpe, pt) match {
         case (defn.ArrayType(treeElem), defn.ArrayType(ptElem))
@@ -144,6 +147,7 @@ object Erasure {
           ctx.log(s"casting from ${tree.showSummary}: ${tree.tpe.show} to ${pt.show}")
           mkAsInstanceOf(tree, pt)
       }
+    }
 
     /** Adaptation of an expression `e` to an expected type `PT`, applying the following
      *  rewritings exhaustively as long as the type of `e` is not a subtype of `PT`.