First stab at type methods

Allow types to be parameterized over terms. Parameterized type definitions
are treated analogously to transparent methods.

Author: odersky

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

@@ -106,7 +106,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
       Closure(Nil, call, targetTpt))
   }
 
-  /** A closure whole anonymous function has the given method type */
+  /** A closure whose anonymous function has the given method type */
   def Lambda(tpe: MethodType, rhsFn: List[Tree] => Tree)(implicit ctx: Context): Block = {
     val meth = ctx.newSymbol(ctx.owner, nme.ANON_FUN, Synthetic | Method, tpe)
     Closure(meth, tss => rhsFn(tss.head).changeOwner(ctx.owner, meth))

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

@@ -792,7 +792,8 @@ object SymDenotations {
       is(InlineMethod, butNot = Accessor)
 
     def isTransparentMethod(implicit ctx: Context): Boolean =
-      is(TransparentMethod, butNot = AccessorOrSynthetic)
+      is(TransparentMethod, butNot = AccessorOrSynthetic) ||
+      is(TypeMethod)
 
     def isInlineableMethod(implicit ctx: Context) = isInlinedMethod || isTransparentMethod
 

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

@@ -993,6 +993,14 @@ object Types {
       case _ => this
     }
 
+    /** Widen, and if result is a typeref with a type lambda as alias or upper bound,
+     *  widen again to the lambda
+     */
+    final def widenToLambda(implicit ctx: Context): Type = widen match {
+      case tp: TypeRef if tp.info.hiBound.isInstanceOf[LambdaType] => tp.info.hiBound
+      case tp => tp
+    }
+
     /** If this type contains embedded union types, replace them by their joins.
      *  "Embedded" means: inside intersectons or recursive types, or in prefixes of refined types.
      *  If an embedded union is found, we first try to simplify or eliminate it by

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

@@ -770,11 +770,11 @@ class TreeUnpickler(reader: TastyReader,
           val tparams = readParams[TypeDef](TYPEPARAM)(localCtx)
           val vparamss = readParamss(localCtx)
           val tpt = readTpt()(localCtx)
-          val typeParams = tparams.map(_.symbol)
+          val typeParams = tparams.map(_.symbol.asType)
           val valueParamss = ctx.normalizeIfConstructor(
-              vparamss.nestedMap(_.symbol), name == nme.CONSTRUCTOR)
+              vparamss.nestedMap(_.symbol.asTerm), name == nme.CONSTRUCTOR)
           val resType = ctx.effectiveResultType(sym, typeParams, tpt.tpe)
-          sym.info = ctx.methodType(typeParams, valueParamss, resType)
+          sym.info = ctx.termLambda(typeParams, valueParamss, resType, sym)
           DefDef(tparams, vparamss, tpt)
         case VALDEF =>
           val tpt = readTpt()(localCtx)

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

@@ -167,7 +167,7 @@ class PlainPrinter(_ctx: Context) extends Printer {
         "<notype>"
       case NoPrefix =>
         "<noprefix>"
-      case tp: MethodType =>
+      case tp: TermLambda =>
         changePrec(GlobalPrec) {
           ("(" + (if (tp.isErasedMethod)   "erased "   else "")
                + (if (tp.isImplicitMethod) "implicit " else "")

compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala

@@ -208,12 +208,12 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
            ": " ~ toText(tp.memberProto) ~ " }"
       case tp: ViewProto =>
         return toText(tp.argType) ~ " ?=>? " ~ toText(tp.resultType)
-      case tp @ FunProto(args, resultType, _) =>
-        val argsText = args match {
+      case tp: FunProto =>
+        val argsText = tp.args  match {
           case dummyTreeOfType(tp) :: Nil if !(tp isRef defn.NullClass) => "null: " ~ toText(tp)
-          case _ => toTextGlobal(args, ", ")
+          case _ => toTextGlobal(tp.args, ", ")
         }
-        return "FunProto(" ~ argsText ~ "):" ~ toText(resultType)
+        return "FunProto(" ~ argsText ~ "):" ~ toText(tp.resultType)
       case tp: IgnoredProto =>
         return "?"
       case tp @ PolyProto(targs, resType) =>
@@ -593,7 +593,9 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
     if (sym.privateWithin.exists) sym.privateWithin.asType.name else tpnme.EMPTY,
     sym.annotations map (_.tree))
 
-  protected def optAscription[T >: Untyped](tpt: Tree[T]) = optText(tpt)(": " ~ _)
+  protected def optAscription[T >: Untyped](tpt: Tree[T])(implicit ctx: Context) =
+    if (tpt.typeOpt.isInstanceOf[TypeBounds]) toText(tpt)
+    else optText(tpt)(": " ~ _)
 
   private def idText(tree: untpd.Tree): Text = {
     if ((ctx.settings.uniqid.value || Printer.debugPrintUnique) && tree.hasType && tree.symbol.exists) s"#${tree.symbol.id}" else ""
@@ -641,7 +643,8 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
   protected def defDefToText[T >: Untyped](tree: DefDef[T]): Text = {
     import untpd.{modsDeco => _, _}
     dclTextOr(tree) {
-      val prefix = modText(tree.mods, tree.symbol, keywordStr("def")) ~~ valDefText(nameIdText(tree))
+      val keyword = if (tree.symbol.isType) "type" else "def"
+      val prefix = modText(tree.mods, tree.symbol, keywordStr(keyword)) ~~ valDefText(nameIdText(tree))
       withEnclosingDef(tree) {
           addVparamssText(prefix ~ tparamsText(tree.tparams), tree.vparamss) ~ optAscription(tree.tpt) ~
             optText(tree.rhs)(" = " ~ _)

compiler/src/dotty/tools/dotc/reporting/StoreReporter.scala

@@ -23,7 +23,8 @@ class StoreReporter(outer: Reporter) extends Reporter {
   protected[this] var infos: mutable.ListBuffer[MessageContainer] = null
 
   def doReport(m: MessageContainer)(implicit ctx: Context): Unit = {
-    typr.println(s">>>> StoredError: ${m.message}") // !!! DEBUG
+    typr.println(s">>>> StoredError: ${m.message}")
+    // new AssertionError().printStackTrace()       // DEBUG
     if (infos == null) infos = new mutable.ListBuffer
     infos += m
   }

compiler/src/dotty/tools/dotc/transform/Erasure.scala

@@ -540,35 +540,37 @@ object Erasure {
      *  with more than `MaxImplementedFunctionArity` parameters to ise a single
      *  parameter of type `[]Object`.
      */
-    override def typedDefDef(ddef: untpd.DefDef, sym: Symbol)(implicit ctx: Context) = {
-      val restpe =
-        if (sym.isConstructor) defn.UnitType
-        else sym.info.resultType
-      var vparamss1 = (outer.paramDefs(sym) ::: ddef.vparamss.flatten) :: Nil
-      var rhs1 = ddef.rhs match {
-        case id @ Ident(nme.WILDCARD) => untpd.TypedSplice(id.withType(restpe))
-        case _ => ddef.rhs
-      }
-      if (sym.isAnonymousFunction && vparamss1.head.length > MaxImplementedFunctionArity) {
-        val bunchedParam = ctx.newSymbol(sym, nme.ALLARGS, Flags.TermParam, JavaArrayType(defn.ObjectType))
-        def selector(n: Int) = ref(bunchedParam)
-          .select(defn.Array_apply)
-          .appliedTo(Literal(Constant(n)))
-        val paramDefs = vparamss1.head.zipWithIndex.map {
-          case (paramDef, idx) =>
-            assignType(untpd.cpy.ValDef(paramDef)(rhs = selector(idx)), paramDef.symbol)
+    override def typedDefDef(ddef: untpd.DefDef, sym: Symbol)(implicit ctx: Context) =
+      if (sym.isType) EmptyTree
+      else {
+        val restpe =
+          if (sym.isConstructor) defn.UnitType
+          else sym.info.resultType
+        var vparamss1 = (outer.paramDefs(sym) ::: ddef.vparamss.flatten) :: Nil
+        var rhs1 = ddef.rhs match {
+          case id @ Ident(nme.WILDCARD) => untpd.TypedSplice(id.withType(restpe))
+          case _ => ddef.rhs
         }
-        vparamss1 = (tpd.ValDef(bunchedParam) :: Nil) :: Nil
-        rhs1 = untpd.Block(paramDefs, rhs1)
+        if (sym.isAnonymousFunction && vparamss1.head.length > MaxImplementedFunctionArity) {
+          val bunchedParam = ctx.newSymbol(sym, nme.ALLARGS, Flags.TermParam, JavaArrayType(defn.ObjectType))
+          def selector(n: Int) = ref(bunchedParam)
+            .select(defn.Array_apply)
+            .appliedTo(Literal(Constant(n)))
+          val paramDefs = vparamss1.head.zipWithIndex.map {
+            case (paramDef, idx) =>
+              assignType(untpd.cpy.ValDef(paramDef)(rhs = selector(idx)), paramDef.symbol)
+          }
+          vparamss1 = (tpd.ValDef(bunchedParam) :: Nil) :: Nil
+          rhs1 = untpd.Block(paramDefs, rhs1)
+        }
+        vparamss1 = vparamss1.mapConserve(_.filterConserve(!_.symbol.is(Flags.Erased)))
+        val ddef1 = untpd.cpy.DefDef(ddef)(
+          tparams = Nil,
+          vparamss = vparamss1,
+          tpt = untpd.TypedSplice(TypeTree(restpe).withPos(ddef.tpt.pos)),
+          rhs = rhs1)
+        super.typedDefDef(ddef1, sym)
       }
-      vparamss1 = vparamss1.mapConserve(_.filterConserve(!_.symbol.is(Flags.Erased)))
-      val ddef1 = untpd.cpy.DefDef(ddef)(
-        tparams = Nil,
-        vparamss = vparamss1,
-        tpt = untpd.TypedSplice(TypeTree(restpe).withPos(ddef.tpt.pos)),
-        rhs = rhs1)
-      super.typedDefDef(ddef1, sym)
-    }
 
     override def typedClosure(tree: untpd.Closure, pt: Type)(implicit ctx: Context) = {
       val xxl = defn.isXXLFunctionClass(tree.typeOpt.typeSymbol)

compiler/src/dotty/tools/dotc/transform/ResolveSuper.scala

@@ -80,13 +80,13 @@ class ResolveSuper extends MiniPhase with IdentityDenotTransformer { thisPhase =
   }
 
   override def transformDefDef(ddef: DefDef)(implicit ctx: Context) = {
-    val meth = ddef.symbol.asTerm
+    val meth = ddef.symbol
     if (meth.isSuperAccessor && !meth.is(Deferred)) {
       assert(ddef.rhs.isEmpty)
       val cls = meth.owner.asClass
       val ops = new MixinOps(cls, thisPhase)
       import ops._
-      polyDefDef(meth, forwarder(rebindSuper(cls, meth)))
+      polyDefDef(meth.asTerm, forwarder(rebindSuper(cls, meth)))
     }
     else ddef
   }

compiler/src/dotty/tools/dotc/transform/TreeChecker.scala

@@ -300,10 +300,12 @@ class TreeChecker extends Phase with SymTransformer {
       tree
     }
 
-    /** Check that all methods have MethodicType */
-    def isMethodType(pt: Type)(implicit ctx: Context): Boolean = pt match {
-      case at: AnnotatedType => isMethodType(at.parent)
-      case _: MethodicType => true  // MethodType, ExprType, PolyType
+    /** Check that all methods have LambdaType or ExprType */
+    def isDefType(tp: Type)(implicit ctx: Context): Boolean = tp match {
+      case _: MethodicType => true // MethodType, ExprType, PolyType
+      case _: LambdaType => true
+      case tp: TypeBounds => isDefType(tp.hi)
+      case tp: AnnotatedType => isDefType(tp.parent)
       case _ => false
     }
 
@@ -406,7 +408,7 @@ class TreeChecker extends Phase with SymTransformer {
           })
 
           val tpdTree = super.typedDefDef(ddef, sym)
-          assert(isMethodType(sym.info), i"wrong type, expect a method type for ${sym.fullName}, but found: ${sym.info}")
+          assert(isDefType(sym.info), i"wrong type, expect a method type for ${sym.fullName}, but found: ${sym.info}")
           tpdTree
         }
       }