Refine followingIsGivenSig to not get confused by postfix as

Author: odersky

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

@@ -80,6 +80,9 @@ object Parsers {
   private val InCase: Region => Region = Scanners.InCase
   private val InCond: Region => Region = Scanners.InBraces
 
+  // TRANSITION
+  val knownTypeNames: Set[TypeName] = Set(tpnme.AnyRef, tpnme.Object)
+
   abstract class ParserCommon(val source: SourceFile)(using Context) {
 
     val in: ScannerCommon
@@ -897,23 +900,68 @@ object Parsers {
         followedByToken(LARROW) // `<-` comes before possible statement starts
     }
 
-    /** Are the next token the "GivenSig" part of a given definition,
+    /** Are the next token the "GivenSig" part of an old-style given definition,
      *  i.e. an identifier followed by type and value parameters, followed by `:`?
-     *  @pre  The current token is an identifier
      */
-    def followingIsGivenSig() =
+    def followingIsGivenSig() = // TRANSITION
       val lookahead = in.LookaheadScanner()
+      var prefixName = EmptyTermName
       if lookahead.isIdent then
+        prefixName = lookahead.name
         lookahead.nextToken()
+      var isOldStyle: Boolean = false
+      def isParamStart = lookahead.token == LPAREN || lookahead.token == LBRACKET
       def skipParams(): Unit =
-        if lookahead.token == LPAREN || lookahead.token == LBRACKET then
-          lookahead.skipParens()
+        if isParamStart then
+          val opening = lookahead.token
+          lookahead.nextToken()
+          if prefixName.isEmpty
+             && (opening == LBRACKET || lookahead.isIdent(nme.using))
+          then isOldStyle = true
+          lookahead.skipParensRest(opening)
           skipParams()
         else if lookahead.isNewLine then
           lookahead.nextToken()
           skipParams()
+      val prefixHasParams = isParamStart
       skipParams()
-      lookahead.isIdent(nme.as)
+      if !lookahead.isIdent(nme.as) then false
+      else
+        lookahead.nextToken()
+        if isOldStyle || !lookahead.isIdent then
+          true
+        else
+          val suffixName = lookahead.name
+          lookahead.nextToken()
+          if isParamStart || lookahead.token == DOT then
+            true
+          else if prefixName.isEmpty then
+            // we have `given (...) as bar with no `using`; it must be new style
+            false
+          else if !prefixHasParams && prefixName == suffixName then
+            // we have `given foo as foo`, so it does not matter how we interpret it
+            true
+          else if knownTypeNames.contains(suffixName.toTypeName) then
+            true
+          else if knownTypeNames.contains(prefixName.toTypeName) then
+            true
+          else
+            // we have one of the following
+            //
+            //   1.   given foo as bar
+            //   2.   given foo[...]... as bar
+            //   3.   given foo(...)... as bar
+            //
+            // Decide on the case of the names; lowercase means bound name
+
+            val prefixIsUpper = Character.isUpperCase(prefixName.head)
+            val suffixIsUpper = Character.isUpperCase(suffixName.head)
+            if prefixIsUpper && !suffixIsUpper then false
+            else if !prefixIsUpper && suffixIsUpper then true
+            else syntaxError(
+              em"ambiguous syntax for given definition; make sure exactly one of $prefixName, $suffixName is capitalized")
+              true
+    end followingIsGivenSig
 
     def followingIsExtension() =
       val next = in.lookahead.token

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

@@ -890,6 +890,9 @@ object Scanners {
     final def skipParens(multiple: Boolean = true): Unit =
       val opening = token
       nextToken()
+      skipParensRest(opening, multiple) // TRANSITION
+
+    final def skipParensRest(opening: Token, multiple: Boolean = true): Unit =
       while token != EOF && token != opening + 1 do
         if token == opening && multiple then skipParens() else nextToken()
       nextToken()

tests/disabled/pos/i7851.scala

@@ -8,11 +8,11 @@ object Wrapper { type Aux[T <: Tuple, WrappedT0 <: Tuple] = Wrapper[T] { type Wr
 
 given Wrapper[EmptyTuple] { type WrappedT = EmptyTuple }
 
-given [T: Wrappable] as Wrapper[T] { type WrappedT = Wrapped[T] }
+given [T: Wrappable] => Wrapper[T] { type WrappedT = Wrapped[T] }
 
 given [H: Wrappable, T <: Tuple, WrappedT0 <: Tuple]
-      (using Wrapper.Aux[T, WrappedT0])
-      as Wrapper[H *: T]:
+      => Wrapper.Aux[T, WrappedT0]
+      => Wrapper[H *: T]:
   type WrappedT = Wrapped[H] *: WrappedT0
 
 def wrappedFunction[F, FArgs <: Tuple, WrapperFArgs <: Tuple, R: Wrappable](

tests/pos/i5915.scala

@@ -2,8 +2,8 @@ trait RunDSL
 
 val rdsl = new RunDSL {}
 
-given RunNNFExpr[B] as RunDSL = rdsl
+given runNNFExpr[B] as RunDSL = rdsl
 
-given RunNNFImpl[B] as RunDSL {
+given runNNFImpl[B] as RunDSL {
   //override def runDSL(b: NNF[B]): B = b.terminal
 }

tests/pos/i5978.scala

@@ -84,9 +84,9 @@ package p3 {
 package p4 {
   class TC
 
-  given A as TC
+  given a as TC
 
-  given B[X[_], Y] as TC
+  given b[X[_], Y] as TC
 
-  given C(using TC) as TC
+  given c(using TC) as TC
 }

tests/run/extmethod-overload.scala

@@ -61,7 +61,7 @@ object Test extends App {
       extension [T](xs: List[T]) def +++ (ys: List[T]): List[T] = xs ++ ys ++ ys
       extension [T](xs: List[T]) def +++ (ys: Iterator[T]): List[T] = xs ++ ys ++ ys
     }
-    given Bar as Foo
+    given bar as Foo
 
     assert((1 |+| 2) == 3)
     assert((1 |+| "2") == 2)
@@ -74,7 +74,7 @@ object Test extends App {
 
   // Test with extension methods coming from given alias
   object test4 {
-    given test3.Foo = test3.Bar
+    given test3.Foo = test3.bar
 
     assert((1 |+| 2) == 3)
     assert((1 |+| "2") == 2)