Adapt given instance definitions

Author: odersky

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

@@ -3549,7 +3549,7 @@ object Parsers {
         syntaxError(i"extension clause can only define methods", stat.span)
     }
 
-    /** GivenDef          ::=  [GivenSig] (Type [‘=’ Expr] | StructuralInstance)
+    /** GivenDef          ::=  [GivenSig] (Type [‘=’ Expr] | ConstrApps TemplateBody)
      *  GivenSig          ::=  [id] [DefTypeParamClause] {UsingParamClauses} ‘:’
      */
     def givenDef(start: Offset, mods: Modifiers, givenMod: Mod) = atSpan(start, nameStart) {
@@ -3567,10 +3567,9 @@ object Parsers {
         newLinesOpt()
         val noParams = tparams.isEmpty && vparamss.isEmpty
         if !(name.isEmpty && noParams) then accept(COLON)
-        val parents =
-          if isSimpleLiteral then toplevelTyp() :: Nil
-          else constrApp() :: withConstrApps()
+        val parents = if isSimpleLiteral then toplevelTyp() :: Nil else constrApps()
         val parentsIsType = parents.length == 1 && parents.head.isType
+        newLineOptWhenFollowedBy(LBRACE)
         if in.token == EQUALS && parentsIsType then
           accept(EQUALS)
           mods1 |= Final
@@ -3579,17 +3578,17 @@ object Parsers {
             ValDef(name, parents.head, subExpr())
           else
             DefDef(name, joinParams(tparams, vparamss), parents.head, subExpr())
-        else if in.token != WITH && parentsIsType then
-          if name.isEmpty then
-            syntaxError(em"anonymous given cannot be abstract")
-          DefDef(name, joinParams(tparams, vparamss), parents.head, EmptyTree)
-        else
+        else if isTemplateBodyStart then
           val tparams1 = tparams.map(tparam => tparam.withMods(tparam.mods | PrivateLocal))
           val vparamss1 = vparamss.map(_.map(vparam =>
             vparam.withMods(vparam.mods &~ Param | ParamAccessor | Protected)))
-          val templ = withTemplate(makeConstructor(tparams1, vparamss1), parents)
+          val templ = templateBodyOpt(makeConstructor(tparams1, vparamss1), parents, Nil)
           if noParams then ModuleDef(name, templ)
           else TypeDef(name.toTypeName, templ)
+        else
+          if name.isEmpty then
+            syntaxError(em"anonymous given cannot be abstract")
+          DefDef(name, joinParams(tparams, vparamss), parents.head, EmptyTree)
       end gdef
       finalizeDef(gdef, mods1, start)
     }
@@ -3779,14 +3778,6 @@ object Parsers {
       vd
     }
 
-    /** with Template, with EOL <indent> interpreted */
-    def withTemplate(constr: DefDef, parents: List[Tree]): Template =
-      if in.token != WITH then syntaxError(em"`with` expected")
-      possibleTemplateStart() // consumes a WITH token
-      val (self, stats) = templateBody()
-      Template(constr, parents, Nil, self, stats)
-        .withSpan(Span(constr.span.orElse(parents.head.span).start, in.lastOffset))
-
 /* -------- STATSEQS ------------------------------------------- */
 
     /** Create a tree representing a packaging */

docs/docs/internals/syntax.md

@@ -385,9 +385,8 @@ ClassConstr       ::=  [ClsTypeParamClause] [ConstrMods] ClsParamClauses
 ConstrMods        ::=  {Annotation} [AccessModifier]
 ObjectDef         ::=  id [Template]                                            ModuleDef(mods, name, template)  // no constructor
 EnumDef           ::=  id ClassConstr InheritClauses EnumBody
-GivenDef          ::=  [GivenSig] (Type [‘=’ Expr] | StructuralInstance)
+GivenDef          ::=  [GivenSig] (Type [‘=’ Expr] | ConstrApps TemplateBody)
 GivenSig          ::=  [id] [DefTypeParamClause] {UsingParamClause} ‘:’         -- one of `id`, `DefParamClause`, `UsingParamClause` must be present
-StructuralInstance ::=  ConstrApp {‘with’ ConstrApp} TemplateBody
 Extension         ::=  ‘extension’ [DefTypeParamClause] ‘(’ DefParam ‘)’
                        {UsingParamClause}] ExtMethods
 ExtMethods        ::=  ExtMethod | [nl] ‘{’ ExtMethod {semi ExtMethod ‘}’

docs/docs/reference/contextual/givens.md

@@ -153,11 +153,10 @@ Here is the syntax for given instances:
 ```
 TmplDef             ::=  ...
                      |   ‘given’ GivenDef
-GivenDef            ::=  [GivenSig] StructuralInstance
+GivenDef            ::=  [GivenSig] ConstrApps TemplateBody
                      |   [GivenSig] Type ‘=’ Expr
                      |   [GivenSig] Type
 GivenSig            ::=  [id] [DefTypeParamClause] {UsingParamClause} ‘:’
-StructuralInstance  ::=  ConstrApp {‘with’ ConstrApp} ‘with’ TemplateBody
 ```
 
 A given instance starts with the reserved word `given` and an optional _signature_. The signature

tests/pos-custom-args/erased/i7868.scala

@@ -12,13 +12,14 @@ object Coproduct {
 
   object At {
 
-    given atHead[Head, Tail]: At[Head +: Tail, Head, 0] with {
+    given atHead[Head, Tail]: At[Head +: Tail, Head, 0] {
       def cast: Head <:< Head +: Tail = summon[Head <:< Head +: Tail]
     }
 
     given atTail[Head, Tail, Value, NextIndex <: Int]
           (using atNext: At[Tail, Value, NextIndex])
-      : At[Head +: Tail, Value, S[NextIndex]] with
+      : At[Head +: Tail, Value, S[NextIndex]]
+    with
       val cast: Value <:< Head +: Tail = atNext.cast
 
     given [A](using A): (() => A) = { () => summon[A]}