Merge pull request #7794 from dotty-staging/fix-#7788

Fix #7788: Add new syntax for conditional given instances

Author: anatoliykmetyuk

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

@@ -901,6 +901,7 @@ object Parsers {
 
     /** Are the next tokens a prefix of a formal parameter or given type?
      *  @pre: current token is LPAREN
+     *  TODO: Drop once syntax has stabilized
      */
     def followingIsParamOrGivenType() =
       val lookahead = in.LookaheadScanner()
@@ -915,6 +916,22 @@ object Parsers {
         else false
       else false
 
+    /** Are the next tokens a prefix of a formal parameter?
+     *  @pre: current token is LPAREN
+     */
+     def followingIsParam() =
+      val lookahead = in.LookaheadScanner()
+      lookahead.nextToken()
+      if startParamTokens.contains(lookahead.token) then true
+      else if lookahead.token == IDENTIFIER then
+        if lookahead.name == nme.inline then
+          lookahead.nextToken()
+        if lookahead.token == IDENTIFIER then
+          lookahead.nextToken()
+          lookahead.token == COLON
+        else false
+      else false
+
     /** Are the next token the "GivenSig" part of a given definition,
      *  i.e. an identifier followed by type and value parameters, followed by `:`?
      *  @pre  The current token is an identifier
@@ -2766,15 +2783,20 @@ object Parsers {
     def typeParamClauseOpt(ownerKind: ParamOwner.Value): List[TypeDef] =
       if (in.token == LBRACKET) typeParamClause(ownerKind) else Nil
 
-    /** OLD: GivenTypes   ::=  AnnotType {‘,’ AnnotType}
-     *  NEW: GivenTypes   ::=  Type {‘,’ Type}
-     */
-    def givenTypes(nparams: Int, ofClass: Boolean): List[ValDef] =
-      val tps = commaSeparated(typ)
+    def typesToGivenParams(tps: List[Tree], ofClass: Boolean, nparams: Int): List[ValDef] =
       var counter = nparams
       def nextIdx = { counter += 1; counter }
       val paramFlags = if ofClass then Private | Local | ParamAccessor else Param
-      tps.map(makeSyntheticParameter(nextIdx, _, paramFlags | Synthetic | Given))
+      val tps1 = tps match
+        case Tuple(tps1) :: Nil => tps1
+        case _ => tps
+      tps1.map(makeSyntheticParameter(nextIdx, _, paramFlags | Synthetic | Given))
+
+    /** OLD: GivenTypes   ::=  AnnotType {‘,’ AnnotType}
+     *  NEW: GivenTypes   ::=  Type {‘,’ Type}
+     */
+    def givenTypes(ofClass: Boolean, nparams: Int): List[ValDef] =
+      typesToGivenParams(commaSeparated(typ), ofClass, nparams)
 
     /** ClsParamClause    ::=  ‘(’ [‘erased’] ClsParams ‘)’
      *  GivenClsParamClause::= ‘(’ ‘given’ [‘erased’] (ClsParams | GivenTypes) ‘)’
@@ -2873,7 +2895,7 @@ object Parsers {
                 || startParamTokens.contains(in.token)
                 || isIdent && (in.name == nme.inline || in.lookaheadIn(BitSet(COLON)))
               if isParams then commaSeparated(() => param())
-              else givenTypes(nparams, ofClass)
+              else givenTypes(ofClass, nparams)
           checkVarArgsRules(clause)
           clause
       }
@@ -3384,12 +3406,13 @@ object Parsers {
         syntaxError(i"extension clause can only define methods", stat.span)
     }
 
-    /** GivenDef       ::=  [GivenSig (‘:’ | <:)] Type ‘=’ Expr
-     *                   |  [GivenSig ‘:’] ConstrApps [[‘with’] TemplateBody]
+    /** GivenDef       ::=  [GivenSig (‘:’ | <:)] {FunArgTypes ‘=>’} AnnotType ‘=’ Expr
+     *                   |  [GivenSig ‘:’] {FunArgTypes ‘=>’} ConstrApps [[‘with’] TemplateBody]
      *                   |  [id ‘:’] ExtParamClause {GivenParamClause} ‘extended’ ‘with’ ExtMethods
      *  GivenSig       ::=  [id] [DefTypeParamClause] {GivenParamClause}
      *  ExtParamClause ::=  [DefTypeParamClause] DefParamClause
      *  ExtMethods     ::=  [nl] ‘{’ ‘def’ DefDef {semi ‘def’ DefDef} ‘}’
+     *  TODO: cleanup once syntax has stabilized
      */
     def givenDef(start: Offset, mods: Modifiers, instanceMod: Mod) = atSpan(start, nameStart) {
       var mods1 = addMod(mods, instanceMod)
@@ -3414,13 +3437,18 @@ object Parsers {
           templ.body.foreach(checkExtensionMethod(tparams, _))
           ModuleDef(name, templ)
         else
-          val hasLabel = !name.isEmpty && in.token == COLON
-          if hasLabel then in.nextToken()
+          var hasLabel = false
+          def skipColon() =
+            if !hasLabel && in.token == COLON then
+              hasLabel = true
+              in.nextToken()
+          if !name.isEmpty then skipColon()
           val tparams = typeParamClauseOpt(ParamOwner.Def)
+          if !tparams.isEmpty then skipColon()
           val paramsStart = in.offset
-          val vparamss =
+          var vparamss =
             if in.token == LPAREN && followingIsParamOrGivenType()
-            then paramClauses()
+            then paramClauses() // todo: ONLY admit a single paramClause
             else Nil
           val isExtension = isIdent(nme.extended)
           def checkAllGivens(vparamss: List[List[ValDef]], what: String) =
@@ -3440,19 +3468,45 @@ object Parsers {
             stats.foreach(checkExtensionMethod(tparams, _))
             ModuleDef(name, Template(makeConstructor(tparams, vparamss), Nil, Nil, self, stats))
           else
-            checkAllGivens(vparamss, "parameter of given instance")
+            def makeGiven(params: List[ValDef]): List[ValDef] =
+              params.map(param => param.withMods(param.mods | Given))
+            def conditionalParents(): List[Tree] =
+              accept(ARROW)
+              if in.token == LPAREN && followingIsParam() then
+                vparamss = vparamss :+ makeGiven(paramClause(vparamss.flatten.length))
+                conditionalParents()
+              else
+                val constrs = constrApps(commaOK = true, templateCanFollow = true)
+                if in.token == ARROW && constrs.forall(_.isType) then
+                  vparamss = vparamss
+                    :+ typesToGivenParams(constrs, ofClass = false, vparamss.flatten.length)
+                  conditionalParents()
+                else constrs
+
+            val isConditional =
+              in.token == ARROW
+              && vparamss.length == 1
+              && (hasLabel || name.isEmpty && tparams.isEmpty)
+            if !isConditional then checkAllGivens(vparamss, "parameter of given instance")
             val parents =
-              if hasLabel then
-                constrApps(commaOK = true, templateCanFollow = true)
-              else if in.token == SUBTYPE then
+              if in.token == SUBTYPE && !hasLabel then
                 if !mods.is(Inline) then
                   syntaxError("`<:` is only allowed for given with `inline` modifier")
                 in.nextToken()
-                TypeBoundsTree(EmptyTree, toplevelTyp()) :: Nil
+                TypeBoundsTree(EmptyTree, annotType()) :: Nil
+              else if isConditional then
+                vparamss = vparamss.map(makeGiven)
+                conditionalParents()
               else
-                if !(name.isEmpty && tparams.isEmpty && vparamss.isEmpty) then
+                if !hasLabel && !(name.isEmpty && tparams.isEmpty && vparamss.isEmpty) then
                   accept(COLON)
-                constrApps(commaOK = true, templateCanFollow = true)
+                val constrs = constrApps(commaOK = true, templateCanFollow = true)
+                if in.token == ARROW && vparamss.isEmpty && constrs.forall(_.isType) then
+                  vparamss = typesToGivenParams(constrs, ofClass = false, 0) :: Nil
+                  conditionalParents()
+                else
+                  constrs
+
             if in.token == EQUALS && parents.length == 1 && parents.head.isType then
               in.nextToken()
               mods1 |= Final

docs/docs/internals/syntax.md

@@ -384,8 +384,10 @@ ClassConstr       ::=  [ClsTypeParamClause] [ConstrMods] ClsParamClauses
 ConstrMods        ::=  {Annotation} [AccessModifier]
 ObjectDef         ::=  id [Template]                                            ModuleDef(mods, name, template)  // no constructor
 EnumDef           ::=  id ClassConstr InheritClauses [‘with’] EnumBody          EnumDef(mods, name, tparams, template)
-GivenDef          ::=  [GivenSig (‘:’ | <:)] Type ‘=’ Expr
-                    |  [GivenSig ‘:’] ConstrApps [[‘with’] TemplateBody]
+GivenDef          ::=  [GivenSig (‘:’ | <:)] {FunArgTypes ‘=>’}
+                       AnnotType ‘=’ Expr
+                    |  [GivenSig ‘:’] {FunArgTypes ‘=>’}
+                       ConstrApps [[‘with’] TemplateBody]
                     |  [id ‘:’] ExtParamClause {GivenParamClause}
                        ‘extended’ ‘with’ ExtMethods
 GivenSig          ::=  [id] [DefTypeParamClause] {GivenParamClause}

docs/docs/reference/contextual/delegates.md

@@ -18,7 +18,7 @@ given intOrd: Ord[Int] {
     if (x < y) -1 else if (x > y) +1 else 0
 }
 
-given listOrd[T](given ord: Ord[T]): Ord[List[T]] {
+given listOrd[T]: (ord: Ord[T]) => Ord[List[T]] {
 
   def compare(xs: List[T], ys: List[T]): Int = (xs, ys) match {
     case (Nil, Nil) => 0
@@ -33,16 +33,18 @@ given listOrd[T](given ord: Ord[T]): Ord[List[T]] {
 This code defines a trait `Ord` with two given instances. `intOrd` defines
 a given for the type `Ord[Int]` whereas `listOrd[T]` defines givens
 for `Ord[List[T]]` for all types `T` that come with a given instance for `Ord[T]` themselves.
-The `(given ord: Ord[T])` clause in `listOrd` defines an implicit parameter.
-Given clauses are further explained in the [next section](./given-clauses.md).
+The `(ord: Ord[T]) =>` clause in `listOrd` defines a condition: There must be a
+given instance of type `Ord[T]` so that a given instance of type `List[Ord[T]]` can
+be synthesized. Such conditions are expanded by the compiler to implicit
+parameters, which are explained in the [next section](./given-clauses.md).
 
 ## Anonymous Given Instances
 
 The name of a given instance can be left out. So the definitions
 of the last section can also be expressed like this:
 ```scala
 given Ord[Int] { ... }
-given [T](given Ord[T]): Ord[List[T]] { ... }
+given [T]: Ord[T] => Ord[List[T]] { ... }
 ```
 If the name of a given is missing, the compiler will synthesize a name from
 the implemented type(s).
@@ -61,7 +63,7 @@ returned for this and all subsequent accesses to `global`.
 Alias givens can be anonymous, e.g.
 ```scala
 given Position = enclosingTree.position
-given (given outer: Context): Context = outer.withOwner(currentOwner)
+given (outer: Context) => Context = outer.withOwner(currentOwner)
 ```
 An alias given can have type parameters and given clauses just like any other given instance, but it can only implement a single type.
 

docs/docs/reference/contextual/derivation.md

@@ -175,7 +175,7 @@ we need to implement a method `Eq.derived` on the companion object of `Eq` that
 a `Mirror[T]`. Here is a possible implementation,
 
 ```scala
-inline given derived[T](given m: Mirror.Of[T]): Eq[T] = {
+inline given derived[T]: (m: Mirror.Of[T]) => Eq[T] = {
   val elemInstances = summonAll[m.MirroredElemTypes]           // (1)
   inline m match {                                             // (2)
     case s: Mirror.SumOf[T]     => eqSum(s, elemInstances)
@@ -281,7 +281,7 @@ object Eq {
         }
     }
 
-  inline given derived[T](given m: Mirror.Of[T]): Eq[T] = {
+  inline given derived[T]: (m: Mirror.Of[T]) => Eq[T] = {
     val elemInstances = summonAll[m.MirroredElemTypes]
     inline m match {
       case s: Mirror.SumOf[T]     => eqSum(s, elemInstances)
@@ -312,7 +312,7 @@ In this case the code that is generated by the inline expansion for the derived
 following, after a little polishing,
 
 ```scala
-given derived$Eq[T](given eqT: Eq[T]): Eq[Opt[T]] =
+given derived$Eq[T]: (eqT: Eq[T]) => Eq[Opt[T]] =
   eqSum(summon[Mirror[Opt[T]]],
     List(
       eqProduct(summon[Mirror[Sm[T]]], List(summon[Eq[T]]))
@@ -329,13 +329,13 @@ As a third example, using a higher level library such as shapeless the type clas
 `derived` method as,
 
 ```scala
-given eqSum[A](given inst: => K0.CoproductInstances[Eq, A]): Eq[A] {
+given eqSum[A] (inst: => K0.CoproductInstances[Eq, A]) => Eq[A] {
   def eqv(x: A, y: A): Boolean = inst.fold2(x, y)(false)(
     [t] => (eqt: Eq[t], t0: t, t1: t) => eqt.eqv(t0, t1)
   )
 }
 
-given eqProduct[A](given inst: K0.ProductInstances[Eq, A]): Eq[A] {
+given eqProduct[A] (inst: K0.ProductInstances[Eq, A]) => Eq[A] {
   def eqv(x: A, y: A): Boolean = inst.foldLeft2(x, y)(true: Boolean)(
     [t] => (acc: Boolean, eqt: Eq[t], t0: t, t1: t) => Complete(!eqt.eqv(t0, t1))(false)(true)
   )

docs/docs/reference/contextual/extension-methods.md

@@ -3,9 +3,6 @@ layout: doc-page
 title: "Extension Methods"
 ---
 
-**Note** The syntax described in this section is currently under revision.
-[Here is the new version which will be implemented in Dotty 0.20](./extension-methods-new.html).
-
 Extension methods allow one to add methods to a type after the type is defined. Example:
 
 ```scala

docs/docs/reference/contextual/implicit-by-name-parameters.md

@@ -12,7 +12,7 @@ trait Codec[T] {
 
 given intCodec: Codec[Int] = ???
 
-given optionCodec[T](given ev: => Codec[T]): Codec[Option[T]] {
+given optionCodec[T]: (ev: => Codec[T]) => Codec[Option[T]] {
   def write(xo: Option[T]) = xo match {
     case Some(x) => ev.write(x)
     case None =>

docs/docs/reference/contextual/relationship-implicits.md

@@ -21,7 +21,7 @@ Given instances can be mapped to combinations of implicit objects, classes and i
     ```
  2. Parameterized given instances are mapped to combinations of classes and implicit methods. E.g.,
     ```scala
-      given listOrd[T](given ord: Ord[T]): Ord[List[T]] { ... }
+      given listOrd[T]: (ord: Ord[T]) => Ord[List[T]] { ... }
     ```
     maps to
     ```scala

library/src-bootstrapped/scala/quoted/Liftable.scala

@@ -103,7 +103,7 @@ object Liftable {
       else '{ Array(${Expr(array(0))}, ${Expr(array.toSeq.tail)}: _*) }
   }
 
-  given iArrayIsLiftable[T: Type](given ltArray: Liftable[Array[T]]): Liftable[IArray[T]] {
+  given iArrayIsLiftable[T: Type]: (ltArray: Liftable[Array[T]]) => Liftable[IArray[T]] {
     def toExpr(iarray: IArray[T]): (given QuoteContext) => Expr[IArray[T]] =
       '{ ${ltArray.toExpr(iarray.asInstanceOf[Array[T]])}.asInstanceOf[IArray[T]] }
   }

tests/neg/i7248.scala

@@ -1,4 +1,4 @@
 object Test extends App {
-  given f[H](given h: H): H = h
+  given f[H]: (h: H) => H = h
   summon[Int]  // error
 }

tests/neg/i7249.scala

@@ -4,6 +4,6 @@ trait F[H, T]
 
 
 object Test extends App {
-  given f[H, T](given h: H, t: T): F[H, T] = ???
+  given f[H, T]: (h: H, t: T) => F[H, T] = ???
   summon[F[Int, Unit]]  // error
 }