Direct representation of higher-kinded types

bridge/src/sbt-test/source-dependencies/signature-change/B.scala

@@ -0,0 +1,3 @@
+object B {
+  val x: Int = A.f1[Any](1)
+}

bridge/src/sbt-test/source-dependencies/signature-change/changes/A0.scala

@@ -0,0 +1,3 @@
+object A {
+  def f1[T](x: Int): Int = 1
+}

bridge/src/sbt-test/source-dependencies/signature-change/changes/A1.scala

@@ -0,0 +1,3 @@
+object A {
+  def f1[T](x: String): Int = 1
+}

bridge/src/sbt-test/source-dependencies/signature-change/changes/A2.scala

@@ -0,0 +1,3 @@
+object A {
+  def f1[T](x: Int): String = ""
+}

bridge/src/sbt-test/source-dependencies/signature-change/changes/A3.scala

@@ -0,0 +1,3 @@
+object A {
+  def f1[T <: Int](x: Int): Int = 1
+}

bridge/src/sbt-test/source-dependencies/signature-change/project/DottyInjectedPlugin.scala

@@ -0,0 +1,17 @@
+import sbt._
+import Keys._
+
+object DottyInjectedPlugin extends AutoPlugin {
+  override def requires = plugins.JvmPlugin
+  override def trigger = allRequirements
+
+  override val projectSettings = Seq(
+    scalaVersion := "0.1-SNAPSHOT",
+    scalaOrganization := "ch.epfl.lamp",
+    scalacOptions += "-language:Scala2",
+    scalaBinaryVersion  := "2.11",
+    autoScalaLibrary := false,
+    libraryDependencies ++= Seq("org.scala-lang" % "scala-library" % "2.11.5"),
+    scalaCompilerBridgeSource := ("ch.epfl.lamp" % "dotty-bridge" % "0.1.1-SNAPSHOT" % "component").sources()
+  )
+}

bridge/src/sbt-test/source-dependencies/signature-change/test

@@ -0,0 +1,20 @@
+# Case 1: parameter type changed
+$ copy-file changes/A0.scala A.scala
+> compile
+$ copy-file changes/A1.scala A.scala
+# Compilation of B.scala should fail because the signature of f changed
+-> compile
+
+# Case 2: return type changed
+$ copy-file changes/A0.scala A.scala
+> compile
+$ copy-file changes/A2.scala A.scala
+# Compilation of B.scala should fail because the signature of f changed
+-> compile
+
+# Case 3: type parameter bounds changed
+$ copy-file changes/A0.scala A.scala
+> compile
+$ copy-file changes/A3.scala A.scala
+# Compilation of B.scala should fail because the signature of f changed
+-> compile

docs/SyntaxSummary.txt

@@ -96,6 +96,7 @@ grammar.
   ClassQualifier    ::=  `[' id `]'
 
   Type              ::=  FunArgTypes `=>' Type                                  Function(ts, t)
+                      |  HkTypeParamClause `->' Type						    TypeLambda(ps, t)
                       |  InfixType
   FunArgTypes       ::=  InfixType
                       | `(' [ FunArgType {`,' FunArgType } ] `)'
@@ -125,7 +126,6 @@ grammar.
   TypeParamBounds   ::=  TypeBounds {`<%' Type} {`:' Type}                      ContextBounds(typeBounds, tps)
 
   Expr              ::=  FunParams `=>' Expr                                    Function(args, expr), Function(ValDef([implicit], id, TypeTree(), EmptyTree), expr)
-                      |  Expr1
   FunParams         ::=  Bindings
                       |  [`implicit'] id
                       |  `_'
@@ -225,7 +225,8 @@ grammar.
   TypTypeParam      ::=  {Annotation} id [HkTypeParamClause] TypeBounds
 
   HkTypeParamClause ::=  `[' HkTypeParam {`,' HkTypeParam} `]'
-  HkTypeParam       ::=  {Annotation} ['+' | `-'] (Id | `_') TypeBounds
+  HkTypeParam       ::=  {Annotation} ['+' | `-'] (Id[HkTypeParamClause] | `_')
+                         TypeBounds
 
   ClsParamClauses   ::=  {ClsParamClause} [[nl] `(' `implicit' ClsParams `)']
   ClsParamClause    ::=  [nl] `(' [ClsParams] ')'
@@ -280,7 +281,7 @@ grammar.
   DefDcl            ::=  DefSig [`:' Type]                                      DefDef(_, name, tparams, vparamss, tpe, EmptyTree)
   DefSig            ::=  id [DefTypeParamClause] DefParamClauses
   TypeDcl           ::=  id [TypTypeParamClause] ['=' Type]                     TypeDefTree(_, name, tparams, tpt)
-                      |  id [HkParamClause] TypeBounds                          TypeDefTree(_, name, tparams, bounds)
+                      |  id [HkTypeParamClause] TypeBounds                      TypeDefTree(_, name, tparams, bounds)
 
   Def               ::=  `val' PatDef
                       |  `var' VarDef

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

@@ -66,7 +66,7 @@ object desugar {
       val relocate = new TypeMap {
         val originalOwner = sym.owner
         def apply(tp: Type) = tp match {
-          case tp: NamedType if tp.symbol.owner eq originalOwner =>
+          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
             if (local.exists) (defctx.owner.thisType select local).dealias

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

@@ -594,6 +594,12 @@ object Trees {
     def forwardTo = tpt
   }
 
+  /** [typeparams] -> tpt */
+  case class TypeLambdaTree[-T >: Untyped] private[ast] (tparams: List[TypeDef[T]], body: Tree[T])
+    extends TypTree[T] {
+    type ThisTree[-T >: Untyped] = TypeLambdaTree[T]
+  }
+
   /** => T */
   case class ByNameTypeTree[-T >: Untyped] private[ast] (result: Tree[T])
   extends TypTree[T] {
@@ -851,6 +857,7 @@ object Trees {
     type OrTypeTree = Trees.OrTypeTree[T]
     type RefinedTypeTree = Trees.RefinedTypeTree[T]
     type AppliedTypeTree = Trees.AppliedTypeTree[T]
+    type TypeLambdaTree = Trees.TypeLambdaTree[T]
     type ByNameTypeTree = Trees.ByNameTypeTree[T]
     type TypeBoundsTree = Trees.TypeBoundsTree[T]
     type Bind = Trees.Bind[T]
@@ -1028,6 +1035,10 @@ object Trees {
         case tree: AppliedTypeTree if (tpt eq tree.tpt) && (args eq tree.args) => tree
         case _ => finalize(tree, untpd.AppliedTypeTree(tpt, args))
       }
+      def TypeLambdaTree(tree: Tree)(tparams: List[TypeDef], body: Tree): TypeLambdaTree = tree match {
+        case tree: TypeLambdaTree if (tparams eq tree.tparams) && (body eq tree.body) => tree
+        case _ => finalize(tree, untpd.TypeLambdaTree(tparams, body))
+      }
       def ByNameTypeTree(tree: Tree)(result: Tree): ByNameTypeTree = tree match {
         case tree: ByNameTypeTree if result eq tree.result => tree
         case _ => finalize(tree, untpd.ByNameTypeTree(result))
@@ -1160,6 +1171,8 @@ object Trees {
           cpy.RefinedTypeTree(tree)(transform(tpt), transformSub(refinements))
         case AppliedTypeTree(tpt, args) =>
           cpy.AppliedTypeTree(tree)(transform(tpt), transform(args))
+        case TypeLambdaTree(tparams, body) =>
+          cpy.TypeLambdaTree(tree)(transformSub(tparams), transform(body))
         case ByNameTypeTree(result) =>
           cpy.ByNameTypeTree(tree)(transform(result))
         case TypeBoundsTree(lo, hi) =>
@@ -1264,6 +1277,9 @@ object Trees {
             this(this(x, tpt), refinements)
           case AppliedTypeTree(tpt, args) =>
             this(this(x, tpt), args)
+          case TypeLambdaTree(tparams, body) =>
+            implicit val ctx: Context = localCtx
+            this(this(x, tparams), body)
           case ByNameTypeTree(result) =>
             this(x, result)
           case TypeBoundsTree(lo, hi) =>

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

@@ -21,7 +21,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
   private def ta(implicit ctx: Context) = ctx.typeAssigner
 
   def Modifiers(sym: Symbol)(implicit ctx: Context): Modifiers = Modifiers(
-    sym.flags & ModifierFlags,
+    sym.flags & (if (sym.isType) ModifierFlags | VarianceFlags else ModifierFlags),
     if (sym.privateWithin.exists) sym.privateWithin.asType.name else tpnme.EMPTY,
     sym.annotations map (_.tree))
 

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

@@ -137,6 +137,7 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
   def OrTypeTree(left: Tree, right: Tree): OrTypeTree = new OrTypeTree(left, right)
   def RefinedTypeTree(tpt: Tree, refinements: List[Tree]): RefinedTypeTree = new RefinedTypeTree(tpt, refinements)
   def AppliedTypeTree(tpt: Tree, args: List[Tree]): AppliedTypeTree = new AppliedTypeTree(tpt, args)
+  def TypeLambdaTree(tparams: List[TypeDef], body: Tree): TypeLambdaTree = new TypeLambdaTree(tparams, body)
   def ByNameTypeTree(result: Tree): ByNameTypeTree = new ByNameTypeTree(result)
   def TypeBoundsTree(lo: Tree, hi: Tree): TypeBoundsTree = new TypeBoundsTree(lo, hi)
   def Bind(name: Name, body: Tree): Bind = new Bind(name, body)

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

@@ -72,10 +72,9 @@ 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, $apply projections are checked that they apply to a
-   *  higher-kinded type.
+  /** If this flag is set, higher-kinded applications are checked for validity
    */
-  final val checkProjections = false
+  final val checkHKApplications = false
 
   /** The recursion depth for showing a summarized string */
   final val summarizeDepth = 2
@@ -98,6 +97,13 @@ object Config {
    */
   final val splitProjections = false
 
+  /** If this flag is on, always rewrite an application `S[Ts]` where `S` is an alias for
+   *  `[Xs] -> U` to `[Xs := Ts]U`. If this flag is off, the rewriting is only done if `S` is a
+   *  reference to an instantiated parameter. Turning this flag on was observed to
+   *  give a ~6% speedup on the JUnit test suite.
+   */
+  final val simplifyApplications = true
+
   /** Initial size of superId table */
   final val InitialSuperIdsSize = 4096
 

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

@@ -23,7 +23,7 @@ abstract class Constraint extends Showable {
   type This <: Constraint
 
   /** Does the constraint's domain contain the type parameters of `pt`? */
-  def contains(pt: PolyType): Boolean
+  def contains(pt: GenericType): Boolean
 
   /** Does the constraint's domain contain the type parameter `param`? */
   def contains(param: PolyParam): Boolean
@@ -79,7 +79,7 @@ abstract class Constraint extends Showable {
    *                 satisfiability but will solved to give instances of
    *                 type variables.
    */
-  def add(poly: PolyType, tvars: List[TypeVar])(implicit ctx: Context): This
+  def add(poly: GenericType, tvars: List[TypeVar])(implicit ctx: Context): This
 
   /** A new constraint which is derived from this constraint by updating
    *  the entry for parameter `param` to `tp`.
@@ -117,18 +117,17 @@ abstract class Constraint extends Showable {
    */
   def narrowBound(param: PolyParam, bound: Type, isUpper: Boolean)(implicit ctx: Context): This
 
-  /** Is entry associated with `pt` removable?
-   *  @param removedParam The index of a parameter which is still present in the
-   *                      entry array, but is going to be removed at the same step,
-   *                      or -1 if no such parameter exists.
+  /** Is entry associated with `pt` removable? This is the case if
+   *  all type parameters of the entry are associated with type variables
+   *  which have their `inst` fields set.
    */
-  def isRemovable(pt: PolyType, removedParam: Int = -1): Boolean
+  def isRemovable(pt: GenericType): Boolean
 
   /** A new constraint with all entries coming from `pt` removed. */
-  def remove(pt: PolyType)(implicit ctx: Context): This
+  def remove(pt: GenericType)(implicit ctx: Context): This
 
   /** The polytypes constrained by this constraint */
-  def domainPolys: List[PolyType]
+  def domainPolys: List[GenericType]
 
   /** The polytype parameters constrained by this constraint */
   def domainParams: List[PolyParam]

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

@@ -6,6 +6,7 @@ import Types._, Contexts._, Symbols._
 import Decorators._
 import config.Config
 import config.Printers._
+import TypeApplications.EtaExpansion
 import collection.mutable
 
 /** Methods for adding constraints and solving them.
@@ -34,6 +35,11 @@ trait ConstraintHandling {
   /** If the constraint is frozen we cannot add new bounds to the constraint. */
   protected var frozenConstraint = false
 
+  /** We are currently comparing lambdas. Used as a flag for
+   *  optimization: when `false`, no need to do an expensive `pruneLambdaParams`
+   */
+  protected var comparingLambdas = false
+
   private def addOneBound(param: PolyParam, bound: Type, isUpper: Boolean): Boolean =
     !constraint.contains(param) || {
       def occursIn(bound: Type): Boolean = {
@@ -163,12 +169,64 @@ trait ConstraintHandling {
         }
       }
     }
+    assert(constraint.contains(param))
     val bound = if (fromBelow) constraint.fullLowerBound(param) else constraint.fullUpperBound(param)
     val inst = avoidParam(bound)
     typr.println(s"approx ${param.show}, from below = $fromBelow, bound = ${bound.show}, inst = ${inst.show}")
     inst
   }
 
+  /** The instance type of `param` in the current constraint (which contains `param`).
+   *  If `fromBelow` is true, the instance type is the lub of the parameter's
+   *  lower bounds; otherwise it is the glb of its upper bounds. However,
+   *  a lower bound instantiation can be a singleton type only if the upper bound
+   *  is also a singleton type.
+   */
+  def instanceType(param: PolyParam, fromBelow: Boolean): Type = {
+    def upperBound = constraint.fullUpperBound(param)
+    def isSingleton(tp: Type): Boolean = tp match {
+      case tp: SingletonType => true
+      case AndType(tp1, tp2) => isSingleton(tp1) | isSingleton(tp2)
+      case OrType(tp1, tp2) => isSingleton(tp1) & isSingleton(tp2)
+      case _ => false
+    }
+    def isFullyDefined(tp: Type): Boolean = tp match {
+      case tp: TypeVar => tp.isInstantiated && isFullyDefined(tp.instanceOpt)
+      case tp: TypeProxy => isFullyDefined(tp.underlying)
+      case tp: AndOrType => isFullyDefined(tp.tp1) && isFullyDefined(tp.tp2)
+      case _ => true
+    }
+    def isOrType(tp: Type): Boolean = tp.stripTypeVar.dealias match {
+      case tp: OrType => true
+      case tp: RefinedOrRecType => isOrType(tp.parent)
+      case AndType(tp1, tp2) => isOrType(tp1) | isOrType(tp2)
+      case WildcardType(bounds: TypeBounds) => isOrType(bounds.hi)
+      case _ => false
+    }
+
+    // First, solve the constraint.
+    var inst = approximation(param, fromBelow)
+
+    // Then, approximate by (1.) - (3.) and simplify as follows.
+    // 1. If instance is from below and is a singleton type, yet
+    // upper bound is not a singleton type, widen the instance.
+    if (fromBelow && isSingleton(inst) && !isSingleton(upperBound))
+      inst = inst.widen
+
+    inst = inst.simplified
+
+    // 2. If instance is from below and is a fully-defined union type, yet upper bound
+    // is not a union type, approximate the union type from above by an intersection
+    // of all common base types.
+    if (fromBelow && isOrType(inst) && isFullyDefined(inst) && !isOrType(upperBound))
+      inst = inst.approximateUnion
+
+    // 3. If instance is from below, and upper bound has open named parameters
+    //    make sure the instance has all named parameters of the bound.
+    if (fromBelow) inst = inst.widenToNamedTypeParams(param.namedTypeParams)
+    inst
+  }
+
   /** Constraint `c1` subsumes constraint `c2`, if under `c2` as constraint we have
    *  for all poly params `p` defined in `c2` as `p >: L2 <: U2`:
    *
@@ -193,9 +251,9 @@ trait ConstraintHandling {
     }
 
   /** The current bounds of type parameter `param` */
-  final def bounds(param: PolyParam): TypeBounds = constraint.entry(param) match {
-    case bounds: TypeBounds => bounds
-    case _ => param.binder.paramBounds(param.paramNum)
+  final def bounds(param: PolyParam): TypeBounds = {
+    val e = constraint.entry(param)
+    if (e.exists) e.bounds else param.binder.paramBounds(param.paramNum)
   }
 
   /** Add polytype `pt`, possibly with type variables `tvars`, to current constraint
@@ -236,6 +294,36 @@ trait ConstraintHandling {
     checkPropagated(s"added $description") {
       addConstraintInvocations += 1
 
+      /** When comparing lambdas we might get constraints such as
+       *  `A <: X0` or `A = List[X0]` where `A` is a constrained parameter
+       *  and `X0` is a lambda parameter. The constraint for `A` is not allowed
+       *  to refer to such a lambda parameter because the lambda parameter is
+       *  not visible where `A` is defined. Consequently, we need to
+       *  approximate the bound so that the lambda parameter does not appear in it.
+       *  If `tp` is an upper bound, we need to approximate with something smaller,
+       *  otherwise something larger.
+       *  Test case in pos/i94-nada.scala. This test crashes with an illegal instance
+       *  error in Test2 when the rest of the SI-2712 fix is applied but `pruneLambdaParams` is
+       *  missing.
+       */
+      def pruneLambdaParams(tp: Type) =
+        if (comparingLambdas && param.binder.isInstanceOf[PolyType]) {
+          val approx = new ApproximatingTypeMap {
+            def apply(t: Type): Type = t match {
+              case t @ PolyParam(tl: TypeLambda, n) =>
+                val effectiveVariance = if (fromBelow) -variance else variance
+                val bounds = tl.paramBounds(n)
+                if (effectiveVariance > 0) bounds.lo
+                else if (effectiveVariance < 0) bounds.hi
+                else NoType
+              case _ =>
+                mapOver(t)
+            }
+          }
+          approx(tp)
+        }
+        else tp
+
       def addParamBound(bound: PolyParam) =
         if (fromBelow) addLess(bound, param) else addLess(param, bound)
 
@@ -281,12 +369,18 @@ trait ConstraintHandling {
           else NoType
         case bound: TypeVar if constraint contains bound.origin =>
           prune(bound.underlying)
-        case bound: PolyParam if constraint contains bound =>
-          if (!addParamBound(bound)) NoType
-          else if (fromBelow) defn.NothingType
-          else defn.AnyType
+        case bound: PolyParam =>
+          constraint.entry(bound) match {
+            case NoType => pruneLambdaParams(bound)
+            case _: TypeBounds =>
+              if (!addParamBound(bound)) NoType
+              else if (fromBelow) defn.NothingType
+              else defn.AnyType
+            case inst =>
+              prune(inst)
+          }
         case _ =>
-          bound
+          pruneLambdaParams(bound)
       }
 
       try bound match {