Merge pull request #500 from dotty-staging/implement/i499

Implement/i499

Author: DarkDimius

docs/SyntaxSummary.txt

@@ -112,8 +112,8 @@ grammar.
   ArgTypes          ::=  ArgType {`,' ArgType}
   FunArgType        ::=  ArgType
                       |  `=>' ArgType                                           PrefixOp(=>, t)
-  ParamType         ::=  FunArgType
-                      |  Type `*'                                               PostfixOp(t, "*")
+  ParamType         ::=  [`=>'] ParamValueType
+  ParamValueType    ::=  Type [`*']                                             PostfixOp(t, "*")
   TypeArgs          ::=  `[' ArgTypes `]'                                       ts
   Refinement        ::=  `{' [Dcl] {semi [Dcl]} `}'                             ds
   TypeBounds        ::=  [`>:' Type] [`<: Type] | INT                           TypeBoundsTree(lo, hi)

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

@@ -289,8 +289,13 @@ object desugar {
         val caseParams = constrVparamss.head.toArray
         val productElemMeths = for (i <- 0 until arity) yield
           syntheticProperty(nme.selectorName(i), Select(This(EmptyTypeName), caseParams(i).name))
+        def isRepeated(tree: Tree): Boolean = tree match {
+          case PostfixOp(_, nme.raw.STAR) => true
+          case ByNameTypeTree(tree1) => isRepeated(tree1)
+          case _ => false
+        }
         val hasRepeatedParam = constrVparamss.exists(_.exists {
-          case ValDef(_, PostfixOp(_, nme.raw.STAR), _) => true
+          case ValDef(_, tpt, _) => isRepeated(tpt)
           case _ => false
         })
         val copyMeths =

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

@@ -160,11 +160,12 @@ trait TreeInfo[T >: Untyped <: Type] { self: Trees.Instance[T] =>
     case _                                => Nil
   }
 
-  /** Is tpt a vararg type of the form T* ? */
-  def isRepeatedParamType(tpt: Tree)(implicit ctx: Context) = tpt match {
+  /** Is tpt a vararg type of the form T* or => T*? */
+  def isRepeatedParamType(tpt: Tree)(implicit ctx: Context): Boolean = tpt match {
+    case ByNameTypeTree(tpt1) => isRepeatedParamType(tpt1)
     case tpt: TypeTree => tpt.typeOpt.isRepeatedParam
-    case AppliedTypeTree(Select(_, tpnme.REPEATED_PARAM_CLASS), _)      => true
-    case _                                                              => false
+    case AppliedTypeTree(Select(_, tpnme.REPEATED_PARAM_CLASS), _) => true
+    case _ => false
   }
 
   /** Is name a left-associative operator? */

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

@@ -282,12 +282,17 @@ class TypeApplications(val self: Type) extends AnyVal {
 
   /** Translate a type of the form From[T] to To[T], keep other types as they are.
    *  `from` and `to` must be static classes, both with one type parameter, and the same variance.
+   *  Do the same for by name types => From[T] and => To[T]
    */
-  def translateParameterized(from: ClassSymbol, to: ClassSymbol)(implicit ctx: Context): Type =
-    if (self.derivesFrom(from))
-      if (ctx.erasedTypes) to.typeRef
-      else RefinedType(to.typeRef, to.typeParams.head.name, self.member(from.typeParams.head.name).info)
-    else self
+  def translateParameterized(from: ClassSymbol, to: ClassSymbol)(implicit ctx: Context): Type = self match {
+    case self @ ExprType(tp) =>
+      self.derivedExprType(tp.translateParameterized(from, to))
+    case _ =>
+      if (self.derivesFrom(from))
+        if (ctx.erasedTypes) to.typeRef
+        else RefinedType(to.typeRef, to.typeParams.head.name, self.member(from.typeParams.head.name).info)
+      else self
+  }
 
   /** If this is repeated parameter type, its underlying Seq type,
    *  or, if isJava is true, Array type, else the type itself.

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

@@ -2066,14 +2066,16 @@ object Types {
     def apply(paramTypes: List[Type], resultType: Type)(implicit ctx: Context): MethodType =
       apply(nme.syntheticParamNames(paramTypes.length), paramTypes, resultType)
     def fromSymbols(params: List[Symbol], resultType: Type)(implicit ctx: Context) = {
-      def paramInfo(param: Symbol): Type = param.info match {
+      def translateRepeated(tp: Type): Type = tp match {
+        case tp @ ExprType(tp1) => tp.derivedExprType(translateRepeated(tp1))
         case AnnotatedType(annot, tp) if annot matches defn.RepeatedAnnot =>
-          val typeSym = param.info.typeSymbol.asClass
+          val typeSym = tp.typeSymbol.asClass
           assert(typeSym == defn.SeqClass || typeSym == defn.ArrayClass)
           tp.translateParameterized(typeSym, defn.RepeatedParamClass)
         case tp =>
           tp
       }
+      def paramInfo(param: Symbol): Type = translateRepeated(param.info)
       def transformResult(mt: MethodType) =
         resultType.subst(params, (0 until params.length).toList map (MethodParam(mt, _)))
       apply(params map (_.name.asTermName), params map paramInfo)(transformResult _)

src/dotty/tools/dotc/parsing/Parsers.scala

@@ -754,17 +754,21 @@ object Parsers {
       if (in.token == ARROW) atPos(in.skipToken()) { ByNameTypeTree(argType()) }
       else argType()
 
-    /** ParamType ::= FunArgType | ArgType `*'
+    /** ParamType ::= [`=>'] ParamValueType
      */
     def paramType(): Tree =
-      if (in.token == ARROW) funArgType()
-      else {
-        val t = argType()
-        if (isIdent(nme.raw.STAR)) {
-          in.nextToken()
-          atPos(t.pos.start) { PostfixOp(t, nme.raw.STAR) }
-        } else t
-      }
+      if (in.token == ARROW) atPos(in.skipToken()) { ByNameTypeTree(paramValueType()) }
+      else paramValueType()
+
+    /** ParamValueType ::= Type [`*']
+     */
+    def paramValueType(): Tree = {
+      val t = typ()
+      if (isIdent(nme.raw.STAR)) {
+        in.nextToken()
+        atPos(t.pos.start) { PostfixOp(t, nme.raw.STAR) }
+      } else t
+    }
 
     /** TypeArgs    ::= `[' ArgType {`,' ArgType} `]'
        */

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

@@ -63,7 +63,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
   }
 
   override def toTextPrefix(tp: Type): Text = controlled {
-    def isOmittable(sym: Symbol) = 
+    def isOmittable(sym: Symbol) =
       if (ctx.settings.verbose.value) false
       else if (homogenizedView) isEmptyPrefix(sym) // drop <root> and anonymous classes, but not scala, Predef.
       else isOmittablePrefix(sym)
@@ -351,6 +351,8 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
         toTextLocal(tpt) ~ " " ~ blockText(refines)
       case AppliedTypeTree(tpt, args) =>
         toTextLocal(tpt) ~ "[" ~ Text(args map argText, ", ") ~ "]"
+      case ByNameTypeTree(tpt) =>
+        "=> " ~ toTextLocal(tpt)
       case TypeBoundsTree(lo, hi) =>
         optText(lo)(" >: " ~ _) ~ optText(hi)(" <: " ~ _)
       case Bind(name, body) =>

src/dotty/tools/dotc/typer/Applications.scala

@@ -330,7 +330,7 @@ trait Applications extends Compatibility { self: Typer =>
               case arg :: Nil if isVarArg(arg) =>
                 addTyped(arg, formal)
               case _ =>
-                val elemFormal = formal.argTypesLo.head
+                val elemFormal = formal.widenExpr.argTypesLo.head
                 args foreach (addTyped(_, elemFormal))
                 makeVarArg(args.length, elemFormal)
             }
@@ -842,7 +842,10 @@ trait Applications extends Compatibility { self: Typer =>
         val tparams = ctx.newTypeParams(alt1.symbol, tp1.paramNames, EmptyFlags, tp1.instantiateBounds)
         isAsSpecific(alt1, tp1.instantiate(tparams map (_.typeRef)), alt2, tp2)
       case tp1: MethodType =>
-        def repeatedToSingle(tp: Type) = if (tp.isRepeatedParam) tp.argTypesHi.head else tp
+        def repeatedToSingle(tp: Type): Type = tp match {
+          case tp @ ExprType(tp1) => tp.derivedExprType(repeatedToSingle(tp1))
+          case _ => if (tp.isRepeatedParam) tp.argTypesHi.head else tp
+        }
         isApplicable(alt2, tp1.paramTypes map repeatedToSingle, WildcardType) ||
         tp1.paramTypes.isEmpty && tp2.isInstanceOf[MethodOrPoly]
       case _ =>

tests/pos/byNameVarargs.scala

@@ -0,0 +1,15 @@
+package test
+
+object O {
+
+  def byname(xs: => Int*) = xs.sum
+  def byval(xs: Int*) = xs.sum
+
+  def a = 1
+  def b = 2
+
+  byval(a, b)
+  byname(a, b)
+
+}
+

tests/run/byNameVarargs/i499.scala

@@ -0,0 +1,28 @@
+object Test {
+  def foo(a: => Any*) = ()
+  def bar(a: => Any*) = foo(a : _*)
+  def baz(a: => Seq[Any]) = foo(a : _*)
+  bar(???, ???)
+  baz(Seq(???, ???))
+  baz(Array(???, ???))
+
+  def foo1(a => Any, b: => Any*) = ()
+  foo1(???)
+  foo1(???, ???, ???)
+
+  def assertFails(a => Any) = {
+   var failed = false 
+   try {
+     a
+   } catch {
+     case e => failed = true
+   }
+   assert(failed)
+  }
+
+  def forceLength(b: => Any*) = b.length
+  assertFails(forceLength(???))
+
+  def forceHead(b: => Any*) = b(0)
+  assertFails(forceHead(1, ???))
+}