Allow given bindings in patterns

Syntax:

    given x: T

Allowed anywhere a pattern is allowed. This is useful in for expressions
and as a replacement of given matches, to name just two cases.

Author: odersky

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

@@ -930,14 +930,18 @@ object desugar {
     else tree
   }
 
+  /** Invent a name for an anonympus given of type or template `impl`. */
+  def inventGivenName(impl: Tree)(implicit ctx: Context): SimpleName =
+    avoidIllegalChars(s"${inventName(impl)}_given".toTermName.asSimpleName)
+
   /** The normalized name of `mdef`. This means
    *   1. Check that the name does not redefine a Scala core class.
    *      If it does redefine, issue an error and return a mangled name instead of the original one.
    *   2. If the name is missing (this can be the case for instance definitions), invent one instead.
    */
   def normalizeName(mdef: MemberDef, impl: Tree)(implicit ctx: Context): Name = {
     var name = mdef.name
-    if (name.isEmpty) name = name.likeSpaced(avoidIllegalChars(s"${inventName(impl)}_given".toTermName.asSimpleName))
+    if (name.isEmpty) name = name.likeSpaced(inventGivenName(impl))
     if (ctx.owner == defn.ScalaPackageClass && defn.reservedScalaClassNames.contains(name.toTypeName)) {
       def kind = if (name.isTypeName) "class" else "object"
       ctx.error(em"illegal redefinition of standard $kind $name", mdef.sourcePos)

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

@@ -308,25 +308,12 @@ object Trees {
   /** Tree defines a new symbol */
   trait DefTree[-T >: Untyped] extends DenotingTree[T] {
     type ThisTree[-T >: Untyped] <: DefTree[T]
-    override def isDef: Boolean = true
-    def namedType: NamedType = tpe.asInstanceOf[NamedType]
-  }
-
-  /** Tree defines a new symbol and carries modifiers.
-   *  The position of a MemberDef contains only the defined identifier or pattern.
-   *  The envelope of a MemberDef contains the whole definition and has its point
-   *  on the opening keyword (or the next token after that if keyword is missing).
-   */
-  abstract class MemberDef[-T >: Untyped](implicit @constructorOnly src: SourceFile) extends NameTree[T] with DefTree[T] {
-    type ThisTree[-T >: Untyped] <: MemberDef[T]
 
     private[this] var myMods: untpd.Modifiers = null
 
     private[dotc] def rawMods: untpd.Modifiers =
       if (myMods == null) untpd.EmptyModifiers else myMods
 
-    def rawComment: Option[Comment] = getAttachment(DocComment)
-
     def withAnnotations(annots: List[untpd.Tree]): ThisTree[Untyped] = withMods(rawMods.withAnnotations(annots))
 
     def withMods(mods: untpd.Modifiers): ThisTree[Untyped] = {
@@ -338,14 +325,28 @@ object Trees {
     def withFlags(flags: FlagSet): ThisTree[Untyped] = withMods(untpd.Modifiers(flags))
     def withAddedFlags(flags: FlagSet): ThisTree[Untyped] = withMods(rawMods | flags)
 
+    /** Destructively update modifiers. To be used with care. */
+    def setMods(mods: untpd.Modifiers): Unit = myMods = mods
+
+    override def isDef: Boolean = true
+    def namedType: NamedType = tpe.asInstanceOf[NamedType]
+  }
+
+  /** Tree defines a new symbol and carries modifiers.
+   *  The position of a MemberDef contains only the defined identifier or pattern.
+   *  The envelope of a MemberDef contains the whole definition and has its point
+   *  on the opening keyword (or the next token after that if keyword is missing).
+   */
+  abstract class MemberDef[-T >: Untyped](implicit @constructorOnly src: SourceFile) extends NameTree[T] with DefTree[T] {
+    type ThisTree[-T >: Untyped] <: MemberDef[T]
+
+    def rawComment: Option[Comment] = getAttachment(DocComment)
+
     def setComment(comment: Option[Comment]): this.type = {
       comment.map(putAttachment(DocComment, _))
       this
     }
 
-    /** Destructively update modifiers. To be used with care. */
-    def setMods(mods: untpd.Modifiers): Unit = myMods = mods
-
     /** The position of the name defined by this definition.
      *  This is a point position if the definition is synthetic, or a range position
      *  if the definition comes from source.

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

@@ -457,7 +457,7 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
 
   abstract class ModsDecorator { def mods: Modifiers }
 
-  implicit class modsDeco(val mdef: MemberDef)(implicit ctx: Context) {
+  implicit class modsDeco(val mdef: DefTree)(implicit ctx: Context) {
     def mods: Modifiers = mdef.rawMods
   }
 

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

@@ -1,4 +1,4 @@
-package dotty.tools
+ package dotty.tools
 package dotc
 package parsing
 
@@ -14,6 +14,7 @@ import Flags._
 import Contexts._
 import Names._
 import NameKinds.WildcardParamName
+import NameOps._
 import ast.{Positioned, Trees}
 import ast.Trees._
 import StdNames._
@@ -202,7 +203,7 @@ object Parsers {
     } && !in.isSoftModifierInModifierPosition
 
     def isExprIntro: Boolean =
-      if (in.token == IMPLIED || in.token == GIVEN) in.lookaheadIn(BitSet(MATCH))
+      if (in.token == GIVEN) in.lookaheadIn(BitSet(MATCH))
       else (canStartExpressionTokens.contains(in.token) && !in.isSoftModifierInModifierPosition)
 
     def isDefIntro(allowedMods: BitSet, excludedSoftModifiers: Set[TermName] = Set.empty): Boolean =
@@ -1645,7 +1646,7 @@ object Parsers {
         if (in.token == MATCH) impliedMatch(start, imods)
         else implicitClosure(start, location, imods)
       }
-      else if (in.token == IMPLIED || in.token == GIVEN) {
+      else if (in.token == GIVEN) {
         in.nextToken()
         if (in.token == MATCH)
           impliedMatch(start, EmptyModifiers)
@@ -2350,16 +2351,34 @@ object Parsers {
       if (isIdent(nme.raw.BAR)) { in.nextToken(); pattern1() :: patternAlts() }
       else Nil
 
-    /**  Pattern1          ::= Pattern2 [Ascription]
+    /**  Pattern1     ::= Pattern2 [Ascription]
+     *                  | ‘given’ PatVar ‘:’ RefinedType
      */
-    def pattern1(): Tree = {
-      val p = pattern2()
-      if (in.token == COLON) {
-        in.nextToken()
-        ascription(p, Location.InPattern)
+    def pattern1(): Tree =
+      if (in.token == GIVEN) {
+        val givenMod = atSpan(in.skipToken())(Mod.Given())
+        atSpan(in.offset) {
+          in.token match {
+            case IDENTIFIER | USCORE if in.name.isVariableName =>
+              val name = in.name
+              in.nextToken()
+              accept(COLON)
+              val typed = ascription(Ident(nme.WILDCARD), Location.InPattern)
+              Bind(name, typed).withMods(addMod(Modifiers(), givenMod))
+            case _ =>
+              syntaxErrorOrIncomplete("pattern variable expected")
+              errorTermTree
+          }
+        }
+      }
+      else {
+        val p = pattern2()
+        if (in.token == COLON) {
+          in.nextToken()
+          ascription(p, Location.InPattern)
+        }
+        else p
       }
-      else p
-    }
 
     /**  Pattern2    ::=  [id `@'] InfixPattern
      */
@@ -2850,7 +2869,7 @@ object Parsers {
      */
     def importClause(leading: Token, mkTree: ImportConstr): List[Tree] = {
       val offset = accept(leading)
-      val importGiven = in.token == IMPLIED || in.token == GIVEN
+      val importGiven = in.token == GIVEN
       if (importGiven) in.nextToken()
       commaSeparated(importExpr(importGiven, mkTree)) match {
         case t :: rest =>
@@ -3203,8 +3222,8 @@ object Parsers {
           objectDef(start, posMods(start, mods | Case | Module))
         case ENUM =>
           enumDef(start, posMods(start, mods | Enum))
-        case IMPLIED | GIVEN =>
-          instanceDef(in.token == GIVEN, start, mods, atSpan(in.skipToken()) { Mod.Given() })
+        case GIVEN =>
+          instanceDef(start, mods, atSpan(in.skipToken()) { Mod.Given() })
         case _ =>
           syntaxErrorOrIncomplete(ExpectedStartOfTopLevelDefinition())
           EmptyTree
@@ -3297,14 +3316,21 @@ object Parsers {
       Template(constr, parents, Nil, EmptyValDef, Nil)
     }
 
-    /** GivenDef          ::=  [id] [DefTypeParamClause] GivenBody
-     *  GivenBody         ::=  [‘as ConstrApp {‘,’ ConstrApp }] {GivenParamClause} [TemplateBody]
-     *                      |  ‘as’ Type {GivenParamClause} ‘=’ Expr
-     *                      |  ‘(’ DefParam ‘)’ TemplateBody
+    /** OLD:
+     *  GivenDef       ::=  [id] [DefTypeParamClause] GivenBody
+     *  GivenBody      ::=  [‘as ConstrApp {‘,’ ConstrApp }] {GivenParamClause} [TemplateBody]
+     *                   |  ‘as’ Type {GivenParamClause} ‘=’ Expr
+     *                   |  ‘(’ DefParam ‘)’ TemplateBody
+     *  NEW:
+     *  GivenDef       ::=  [GivenSig (‘:’ | <:)] Type ‘=’ Expr
+     *                   |  [GivenSig ‘:’] [ConstrApp {‘,’ ConstrApp }] [TemplateBody]
+     *                // |  [id ‘:’] [ExtParamClause] TemplateBody   (not yet implemented)
+     *  ExtParamClause ::=  [DefTypeParamClause] DefParamClause {GivenParamClause}
+     *  GivenSig       ::=  [id] [DefTypeParamClause] {GivenParamClause}
      */
-    def instanceDef(newStyle: Boolean, start: Offset, mods: Modifiers, instanceMod: Mod) = atSpan(start, nameStart) {
+    def instanceDef(start: Offset, mods: Modifiers, instanceMod: Mod) = atSpan(start, nameStart) {
       var mods1 = addMod(mods, instanceMod)
-      val name = if (isIdent && !(newStyle && isIdent(nme.as))) ident() else EmptyTermName
+      val name = if (isIdent && !isIdent(nme.as)) ident() else EmptyTermName
       indentRegion(name) {
         val tparams = typeParamClauseOpt(ParamOwner.Def)
         var leadingParamss =
@@ -3316,7 +3342,7 @@ object Parsers {
             }
           else Nil
         val parents =
-          if (!newStyle && in.token == FOR || isIdent(nme.as)) { // for the moment, accept both `given for` and `given as`
+          if (isIdent(nme.as)) {
             in.nextToken()
             tokenSeparated(COMMA, constrApp)
           }
@@ -3634,7 +3660,7 @@ object Parsers {
           val mods = modifiers(closureMods)
           mods.mods match {
             case givenMod :: Nil if !isBindingIntro =>
-              stats += instanceDef(true, start, EmptyModifiers, Mod.Given().withSpan(givenMod.span))
+              stats += instanceDef(start, EmptyModifiers, Mod.Given().withSpan(givenMod.span))
             case _ =>
               stats += implicitClosure(in.offset, Location.InBlock, mods)
           }

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

@@ -479,7 +479,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
         if (lo eq hi) optText(lo)(" = " ~ _)
         else optText(lo)(" >: " ~ _) ~ optText(hi)(" <: " ~ _)
       case Bind(name, body) =>
-        ("given ": Text).provided(tree.symbol.is(Implicit) && !homogenizedView) ~ // Used for scala.quoted.Type in quote patterns (not pickled)
+        ("given ": Text).provided(tree.symbol.isOneOf(GivenOrImplicit) && !homogenizedView) ~ // Used for scala.quoted.Type in quote patterns (not pickled)
         changePrec(InfixPrec) { toText(name) ~ " @ " ~ toText(body) }
       case Alternative(trees) =>
         changePrec(OrPrec) { toText(trees, " | ") }
@@ -699,7 +699,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
   }
 
   /** Print modifiers from symbols if tree has type, overriding the untpd behavior. */
-  implicit def modsDeco(mdef: untpd.MemberDef)(implicit ctx: Context): untpd.ModsDecorator =
+  implicit def modsDeco(mdef: untpd.DefTree)(implicit ctx: Context): untpd.ModsDecorator =
     new untpd.ModsDecorator {
       def mods = if (mdef.hasType) Modifiers(mdef.symbol) else mdef.rawMods
     }

compiler/src/dotty/tools/dotc/typer/Typer.scala

@@ -1478,18 +1478,23 @@ class Typer extends Namer
         tpd.cpy.UnApply(body1)(fn, Nil,
             typed(untpd.Bind(tree.name, untpd.TypedSplice(arg)).withSpan(tree.span), arg.tpe) :: Nil)
       case _ =>
-        if (tree.name == nme.WILDCARD) body1
+        var name = tree.name
+        if (name == nme.WILDCARD && tree.mods.is(Given)) {
+          val Typed(_, tpt): @unchecked = tree.body
+          name = desugar.inventGivenName(tpt)
+        }
+        if (name == nme.WILDCARD) body1
         else {
           // for a singleton pattern like `x @ Nil`, `x` should get the type from the scrutinee
           // see tests/neg/i3200b.scala and SI-1503
           val symTp =
             if (body1.tpe.isInstanceOf[TermRef]) pt1
             else body1.tpe.underlyingIfRepeated(isJava = false)
-          val sym = ctx.newPatternBoundSymbol(tree.name, symTp, tree.span)
-          if (pt == defn.ImplicitScrutineeTypeRef) sym.setFlag(Given)
+          val sym = ctx.newPatternBoundSymbol(name, symTp, tree.span)
+          if (pt == defn.ImplicitScrutineeTypeRef || tree.mods.is(Given)) sym.setFlag(Given)
           if (ctx.mode.is(Mode.InPatternAlternative))
             ctx.error(i"Illegal variable ${sym.name} in pattern alternative", tree.sourcePos)
-          assignType(cpy.Bind(tree)(tree.name, body1), sym)
+          assignType(cpy.Bind(tree)(name, body1), sym)
         }
     }
   }

docs/docs/internals/syntax.md

@@ -262,6 +262,7 @@ TypeCaseClause    ::=  ‘case’ InfixType ‘=>’ Type [nl]
 
 Pattern           ::=  Pattern1 { ‘|’ Pattern1 }                                Alternative(pats)
 Pattern1          ::=  Pattern2 [‘:’ RefinedType]                               Bind(name, Typed(Ident(wildcard), tpe))
+                    |  ‘given’ PatVar ‘:’ RefinedType
 Pattern2          ::=  [id ‘@’] InfixPattern                                    Bind(name, pat)
 InfixPattern      ::=  SimplePattern { id [cnl] SimplePattern }                 InfixOp(pat, op, pat)
 SimplePattern     ::=  PatVar                                                   Ident(wildcard)

tests/neg/given-pattern.scala

@@ -0,0 +1,14 @@
+
+
+class Test {
+  import scala.collection.immutable.{TreeSet, HashSet}
+
+  def f2[T](x: Ordering[T]) = {
+    val (given y: Ordering[T]) = x
+    new TreeSet[T]    // error: no implicit ordering defined for T
+  }
+  def f3[T](x: Ordering[T]) = {
+    val given y: Ordering[T] = x  // error: pattern expected
+    new TreeSet[T]    // error: no implicit ordering defined for T
+  }
+}

tests/pos/given-pattern.scala

@@ -0,0 +1,31 @@
+
+
+class Test {
+  import scala.collection.immutable.{TreeSet, HashSet}
+  import compiletime.trySummon
+
+  inline def trySummon[S, T](f: PartialFunction[S, T]) <: T = ???
+
+  inline def setFor[T]: Set[T] = trySummon {
+    case given ord: Ordering[T] => new TreeSet[T]
+    case given _: Ordering[T] => new TreeSet[T]
+    case _                => new HashSet[T]
+  }
+
+  def f1[T](x: Ordering[T]) = (x, x) match {
+    case (given y: Ordering[T], _) => new TreeSet[T]
+  }
+  def f2[T](x: Ordering[T]) = {
+    val xs = List(x, x, x)
+    for given y: Ordering[T] <- xs
+    yield new TreeSet[T]
+  }
+  def f3[T](x: Ordering[T]) = (x, x) match {
+    case (given _: Ordering[T], _) => new TreeSet[T]
+  }
+  def f4[T](x: Ordering[T]) = {
+    val xs = List(x, x, x)
+    for given _: Ordering[T] <- xs
+    yield new TreeSet[T]
+  }
+}