WIP - dependent types

Author: liufengyun

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

@@ -702,6 +702,8 @@ class Definitions {
   def TASTYLongSignatureAnnot(implicit ctx: Context) = TASTYLongSignatureAnnotType.symbol.asClass
   lazy val TailrecAnnotType = ctx.requiredClassRef("scala.annotation.tailrec")
   def TailrecAnnot(implicit ctx: Context) = TailrecAnnotType.symbol.asClass
+  lazy val DependentAnnotType = ctx.requiredClassRef("scala.annotation.dependent")
+  def DependentAnnot(implicit ctx: Context) = DependentAnnotType.symbol.asClass
   lazy val SwitchAnnotType = ctx.requiredClassRef("scala.annotation.switch")
   def SwitchAnnot(implicit ctx: Context) = SwitchAnnotType.symbol.asClass
   lazy val ThrowsAnnotType = ctx.requiredClassRef("scala.throws")

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

@@ -1665,6 +1665,10 @@ object SymDenotations {
               case tparams: List[Symbol @unchecked] =>
                 baseTypeOf(tycon).subst(tparams, args)
             }
+          case tp @ RefinedType(parent, name, AnnotatedType(refine, annot))
+          if annot.symbol eq defn.DependentAnnot =>
+            val res = baseTypeOf(tp.superType)
+            res.subst(tp.nonPrivateMember(name).symbol :: Nil, refine :: Nil)
           case tp: TypeProxy =>
             baseTypeOf(tp.superType)
           case AndType(tp1, tp2) =>

compiler/src/dotty/tools/dotc/typer/Namer.scala

@@ -1195,7 +1195,18 @@ class Namer { typer: Typer =>
     if (isConstructor) {
       // set result type tree to unit, but take the current class as result type of the symbol
       typedAheadType(ddef.tpt, defn.UnitType)
-      wrapMethType(ctx.effectiveResultType(sym, typeParams, NoType))
+
+      val base = ctx.effectiveResultType(sym, typeParams, NoType)
+      val refined = termParamss.foldLeft(base) { (acc, termParams) =>
+        termParams.foldLeft(base) { case (acc, termParam) =>
+          val dependentAnnot = termParam.annotations.find(_.symbol eq defn.DependentAnnot)
+          if (dependentAnnot.nonEmpty)
+            RefinedType(acc, termParam.name, AnnotatedType(termParam.termRef, dependentAnnot.get))
+          else acc
+        }
+      }
+
+      wrapMethType(refined)
     }
     else valOrDefDefSig(ddef, sym, typeParams, termParamss, wrapMethType)
   }

library/src/scala/annotation/dependent.scala

@@ -0,0 +1,3 @@
+package scala.annotation
+
+final class dependent extends StaticAnnotation

tests/pos/dependent-1262.scala

@@ -0,0 +1,18 @@
+import scala.annotation.dependent
+
+trait Foo {
+  type Bar
+}
+
+trait Quux(val foo: Foo)
+
+class Child(@dependent override val foo: Foo) extends Quux(foo)
+
+object FooInt extends Foo {
+  type Bar = Int
+}
+
+object Test {
+  val quux = new Child(FooInt)
+  val x: quux.foo.Bar = 3
+}

tests/pos/dependent-class.scala

@@ -0,0 +1,31 @@
+import scala.annotation.dependent
+
+class Animal(name: String)
+
+trait Foo[T]
+class Bar(@dependent val a: Animal) extends Foo[a.type]
+
+class Bag(@dependent val a: Animal) {
+ def g(n: Int): Foo[a.type] = ???
+ def f(n: Int): a.type = ???
+}
+
+object Test {
+  def foo(a: Animal): Foo[a.type] = ???
+
+  val dog = new Animal("dog")
+
+  // new instance
+  new Bar(dog) : Foo[dog.type] // found:    Bar, required: Foo[Animal(Test.dog)]
+
+  // dependent method
+  val c: Foo[dog.type] = foo(dog)        // works well
+
+  // dependent function type
+  val f : (a: Animal) => Foo[a.type] = ???  // works well
+  f(dog) : Foo[dog.type]
+
+  // dependent class method
+  new Bag(dog).g(6) : Foo[dog.type]
+  new Bag(dog).f(5) : dog.type
+}

tests/pos/dependent-t5700.scala

@@ -0,0 +1,12 @@
+import scala.annotation.dependent
+
+trait Foo { type FA }
+class Bar(@dependent val foo: Foo) {
+  type FA = foo.FA
+}
+
+object Test {
+  def main(argv: Array[String]) = {
+    val barLong: Bar { type FA = Long } = new Bar(new Foo { type FA = Long })
+  }
+}