Merge pull request #788 from dotty-staging/fix-#781-context-bounds

Fix #781 context bounds

Author: DarkDimius

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

@@ -118,11 +118,11 @@ object desugar {
    *
    *  Expand default arguments to default getters. E.g,
    *
-   *      def f(x: Int = 1)(y: String = x + "m") = ...
+   *      def f[T: B](x: Int = 1)(y: String = x + "m") = ...
    *  ==>
-   *      def f(x: Int)(y: String) = ...
-   *      def f$default$1 = 1
-   *      def f$default$2(x: Int) = x + "m"
+   *      def f[T](x: Int)(y: String)(implicit evidence$0: B[T]) = ...
+   *      def f$default$1[T] = 1
+   *      def f$default$2[T](x: Int) = x + "m"
    */
   def defDef(meth: DefDef, isPrimaryConstructor: Boolean = false)(implicit ctx: Context): Tree = {
     val DefDef(name, tparams, vparamss, tpt, rhs) = meth
@@ -162,15 +162,20 @@ object desugar {
         Nil
     }
 
-    def normalizedVparamss = vparamss map (_ map (vparam =>
+    def normalizedVparamss = meth1.vparamss map (_ map (vparam =>
       cpy.ValDef(vparam)(rhs = EmptyTree)))
 
+    def dropContextBound(tparam: TypeDef) = tparam.rhs match {
+      case ContextBounds(tbounds, _) => cpy.TypeDef(tparam)(rhs = tbounds)
+      case _ => tparam
+    }
+
     def defaultGetters(vparamss: List[List[ValDef]], n: Int): List[DefDef] = vparamss match {
       case (vparam :: vparams) :: vparamss1 =>
         def defaultGetter: DefDef =
           DefDef(
             name = meth.name.defaultGetterName(n),
-            tparams = meth.tparams map toDefParam,
+            tparams = meth.tparams.map(tparam => dropContextBound(toDefParam(tparam))),
             vparamss = takeUpTo(normalizedVparamss, n),
             tpt = TypeTree(),
             rhs = vparam.rhs

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

@@ -332,6 +332,7 @@ object StdNames {
     val Ref: N                  = "Ref"
     val RootPackage: N          = "RootPackage"
     val RootClass: N            = "RootClass"
+    val Scala2: N               = "Scala2"
     val Select: N               = "Select"
     val StringContext: N        = "StringContext"
     val This: N                 = "This"

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

@@ -258,6 +258,9 @@ object Parsers {
       } finally inFunReturnType = saved
     }
 
+    /** Cannot use ctx.featureEnabled because accessing the context would force too much */
+    private def scala2mode = ctx.settings.language.value.contains(nme.Scala2.toString)
+
 /* ---------- TREE CONSTRUCTION ------------------------------------------- */
 
     /** Convert tree to formal parameter list
@@ -1713,22 +1716,23 @@ object Parsers {
      *  DefSig ::= id [DefTypeParamClause] ParamClauses
      */
     def defDefOrDcl(mods: Modifiers): Tree = atPos(tokenRange) {
+      def atScala2Brace = scala2mode && in.token == LBRACE
       if (in.token == THIS) {
         in.nextToken()
         val vparamss = paramClauses(nme.CONSTRUCTOR)
         val rhs = {
-          accept(EQUALS)
+          if (!atScala2Brace) accept(EQUALS)
           atPos(in.offset) { constrExpr() }
         }
         makeConstructor(Nil, vparamss, rhs).withMods(mods)
       } else {
         val name = ident()
         val tparams = typeParamClauseOpt(ParamOwner.Def)
         val vparamss = paramClauses(name)
-        val tpt = fromWithinReturnType(typedOpt())
+        var tpt = fromWithinReturnType(typedOpt())
         val rhs =
           if (tpt.isEmpty || in.token == EQUALS) {
-            accept(EQUALS)
+            if (atScala2Brace) tpt = scalaUnit else accept(EQUALS)
             expr()
           } else EmptyTree
         DefDef(name, tparams, vparamss, tpt, rhs).withMods(mods | Method)