Named tuples are ambigious in (new) given syntax

[SrTobi]

Compiler version

3.6.2 with -experimental

Minimized example

I'm currently implementing the new given syntax parsing for the intellij-scala plugin and I stumbled about this:

given (x: Int) = ???

Output

The compiler gives ')' expected, but ':' found as error message.

Expectation

According to the grammar the above code should be allowed
as named tuples are part of SimpleType.

Here the relevant grammar:

GivenDef          ::=  [id ':'] GivenSig
GivenSig          ::=  GivenImpl
                    |  '(' ')' '=>' GivenImpl
                    |  GivenConditional '=>' GivenSig
GivenImpl         ::=  GivenType ([‘=’ Expr] | TemplateBody)
                    |  ...
GivenConditional  ::=  DefTypeParamClause
                    |  DefTermParamClause
                    |  ...
                    |  GivenType 
GivenType         ::=  AnnotType1 {id [nl] AnnotType1}
AnnotType         ::=  SimpleType {Annotation}

DefTermParamClause and GivenType can look the same ((x: Int) for example)

I know that it doesn't make too much sense to have a named tuple in that position, still I'd like to know if that is intentional or not. Just so I don't have to implement and test our parser twice 😀

In the case that is should stay disallowed, I'd suggest changing the error message either to => expected after the ) or something like named tuples are not allowed in this position

[EugeneFlesselle]

The -experimental option will allow @experimental definitions. An import scala.language.experimental.namedTuples is necessary to use named tuples. Having imported it, the given (x: Int) = ??? parses as expected, on the current main branch at least.

[KacperFKorban]

@SrTobi The following code compiles correctly:

//> using scala 3.nightly

import scala.language.experimental.namedTuples

given (x: Int) = ???

[SrTobi]

Ah ok... I was confused by the fact that val x: (y: Int) = ??? compiles when -experimental is used.

Also the example doesn't even relate to what I mean with the above mentioned ambiguity. The example I should have given (pun intended) is: given (x: Int) => Int = ???
Here (x: Int) can be both DefTermParamClause and GivenType in GivenConditional. Currently it's parsed as a DefTermParamClause and I'm going forward with implementing it that way on our side.

Not sure if you want to change anything in the grammar. if not feel free to close this issue. Thx

[EugeneFlesselle]

given (x: Int) => Int = ???

Good point, this one indeed appears to be ambiguous. Though any changes to the grammar will most likely reflect the current behavior.

[sjrd]

GivenConditional is supposed to win here. If you really want a given of a function type, you need to put the function type in parentheses. (but that should almost never happen in real programs, because why would you even want a given of a function type other than to design a puzzler?)

[SrTobi]

@sjrd it's not about function type vs given conditional+givenImpl, but about parameter clause vs named tuple within a given conditional