Disallow empty implicit parameter sections

Previously, `given ()`  was legal, but it serves no purpose and only complicates things.

Author: odersky

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

@@ -2038,7 +2038,7 @@ object Parsers {
      *  ClsParams         ::=  ClsParam {`' ClsParam}
      *  ClsParam          ::=  {Annotation} [{Modifier} (`val' | `var') | `inline'] Param
      *  DefParamClause    ::=  [nl] `(' [FunArgMods] [DefParams] ')' | InstParamClause
-     *  InstParamClause   ::=  ‘with’ (‘(’ [DefParams] ‘)’ | ContextTypes)
+     *  InstParamClause   ::=  ‘given’ (‘(’ DefParams ‘)’ | ContextTypes)
      *  ContextTypes      ::=  RefinedType {`,' RefinedType}
      *  DefParams         ::=  DefParam {`,' DefParam}
      *  DefParam          ::=  {Annotation} [`inline'] Param
@@ -2109,10 +2109,11 @@ object Parsers {
 
       // begin paramClause
       inParens {
-        if (in.token == RPAREN && !prefix) Nil
+      	val isContextual = impliedMods.is(Contextual)
+        if (in.token == RPAREN && !prefix && !isContextual) Nil
         else {
           def funArgMods(mods: Modifiers): Modifiers =
-            if (in.token == IMPLICIT && !mods.is(Contextual))
+            if (in.token == IMPLICIT && !isContextual)
               funArgMods(addMod(mods, atSpan(accept(IMPLICIT)) { Mod.Implicit() }))
             else if (in.token == ERASED)
               funArgMods(addMod(mods, atSpan(accept(ERASED)) { Mod.Erased() }))
@@ -2148,7 +2149,7 @@ object Parsers {
         newLineOptWhenFollowedBy(LPAREN)
         if (in.token == LPAREN) {
           if (ofInstance && !isContextual)
-            syntaxError(em"parameters of instance definitions must come after `with'")
+            syntaxError(em"parameters of instance definitions must come after `given'")
           val params = paramClause(
               ofClass = ofClass,
               ofCaseClass = ofCaseClass,

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

@@ -131,12 +131,11 @@ trait NamerContextOps { this: Context =>
       termParamss
 
   /** The method type corresponding to given parameters and result type */
-  def methodType(typeParams: List[Symbol], valueParamss: List[List[Symbol]], resultType: Type,
-                 isJava: Boolean = false, isInstance: Boolean = false)(implicit ctx: Context): Type = {
+  def methodType(typeParams: List[Symbol], valueParamss: List[List[Symbol]], resultType: Type, isJava: Boolean = false)(implicit ctx: Context): Type = {
     val monotpe =
       (valueParamss :\ resultType) { (params, resultType) =>
         val (isImplicit, isErased, isContextual) =
-          if (params.isEmpty) (isInstance, false, false)
+          if (params.isEmpty) (false, false, false)
           else (params.head is Implicit, params.head is Erased, params.head.is(Contextual))
         val make = MethodType.maker(isJava = isJava, isImplicit = isImplicit, isErased = isErased, isContextual = isContextual)
         if (isJava)
@@ -1301,8 +1300,7 @@ class Namer { typer: Typer =>
     val termParamss = ctx.normalizeIfConstructor(vparamss.nestedMap(symbolOfTree), isConstructor)
     def wrapMethType(restpe: Type): Type = {
       instantiateDependent(restpe, typeParams, termParamss)
-      ctx.methodType(tparams map symbolOfTree, termParamss, restpe,
-        isJava = ddef.mods is JavaDefined, isInstance = ddef.mods.hasMod(classOf[Mod.Instance]))
+      ctx.methodType(tparams map symbolOfTree, termParamss, restpe, isJava = ddef.mods is JavaDefined)
     }
     if (isConstructor) {
       // set result type tree to unit, but take the current class as result type of the symbol

tests/neg/contextual-params.scala renamed to tests/neg/implicit-params.scala

@@ -6,6 +6,8 @@ object Test {
 
   def g(x: Int) given (c: C) (y: Int) = x + c.x + y
 
+  def h(x: Int) given () = x // error
+
   implicit object C extends C(11)
 
   f(1)