Remove syntactic deviation for ascriptions in parentheses

Previously the parser accepted `(x: A => B)` as an expression, but
only if there were parentheses around it. This was necessary so that
we could parse a potential formal parameter of a closure `(x: A => B) => ...`
as an expression and then convert to a type. But it is not backed
by the grammar. The grammar requires `x: (A => B)` whether in
parentheses or not.

This commit removes the deviation and aligns the parser with the syntax.

Author: odersky

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

@@ -40,14 +40,14 @@ object Parsers {
 
   case class OpInfo(operand: Tree, operator: Ident, offset: Offset)
 
-  enum Location(val inParens: Boolean, val inPattern: Boolean, val inArgs: Boolean):
-    case InParens      extends Location(true, false, false)
-    case InArgs        extends Location(true, false, true)
-    case InPattern     extends Location(false, true, false)
-    case InGuard       extends Location(false, false, false)
-    case InPatternArgs extends Location(false, true, true) // InParens not true, since it might be an alternative
-    case InBlock       extends Location(false, false, false)
-    case ElseWhere     extends Location(false, false, false)
+  enum Location(val inPattern: Boolean, val inArgs: Boolean):
+    case InParens      extends Location(false, false)
+    case InArgs        extends Location(false, true)
+    case InPattern     extends Location(true, false)
+    case InGuard       extends Location(false, false)
+    case InPatternArgs extends Location(true, true)
+    case InBlock       extends Location(false, false)
+    case ElseWhere     extends Location(false, false)
 
   enum ParamOwner:
     case Class, Type, TypeParam, Def
@@ -1860,8 +1860,7 @@ object Parsers {
       else TypeTree().withSpan(Span(in.lastOffset))
 
     def typeDependingOn(location: Location): Tree =
-      if location.inParens then typ()
-      else if location.inPattern then rejectWildcardType(refinedType())
+      if location.inPattern then rejectWildcardType(refinedType())
       else infixType()
 
 /* ----------- EXPRESSIONS ------------------------------------------------ */

tests/pos/i7851.scala

@@ -30,7 +30,7 @@ object WrapperTest {
   val test2: (Wrapped[Float], Wrapped[Float], Wrapped[Float]) => Wrapped[Float] = { (x, y, z) => x }
 
   def main(args: Array[String]): Unit = {
-    wrappedFunction(test1: (Wrapped[Float], Wrapped[Float], Wrapped[Float]) => Wrapped[Float])(5f, 11f, 3f)
+    wrappedFunction(test1: ((Wrapped[Float], Wrapped[Float], Wrapped[Float]) => Wrapped[Float]))(5f, 11f, 3f)
     wrappedFunction(test1)(5f, 11f, 3f)
     wrappedFunction(test2)(5f, 11f, 3f)
   }

tests/pos/t4176b.scala

@@ -1,5 +1,5 @@
 object Test {
      def foo(a1: String*) = a1
 //     val fooEta = foo _
-     (foo: Seq[String] => Seq[String])
+     foo: (Seq[String] => Seq[String])
 }

tests/pos/t8120.scala

@@ -5,5 +5,5 @@ object A {
   implicit class RichAny(a: Any) {
     def m(a: Any): Int = 0
   }
-  (new C).m({ case (x, y) => x } : Any => Any)
+  (new C).m({ case (x, y) => x } : (Any => Any))
 }

tests/run-macros/quote-matching-optimize-4/Macro_1.scala

@@ -22,7 +22,7 @@ object Macro {
     case '{ ($ls: List[T]).filter($f).filter($g) } =>
       optimize('{ $ls.filter(x => $f(x) && $g(x)) })
 
-    case '{ type u; type v; ($ls: List[`u`]).map($f: `u` => `v`).map($g: `v` => T) } =>
+    case '{ type u; type v; ($ls: List[`u`]).map($f: (`u` => `v`)).map($g: (`v` => T)) } =>
       optimize('{ $ls.map(x => $g($f(x))) })
 
     case _ => x

tests/run/lambda-unit.scala

@@ -13,7 +13,7 @@ object Test {
 
   def main(args: Array[String]): Unit = {
     fun("")
-    (fun: Object => Any)("")
+    (fun: (Object => Any))("")
     sam.foo("")
     genericSam.foo("")
   }