Merge pull request #10613 from dotty-staging/drop-old-given-syntax

Drop old given syntax

Author: nicolasstucki

community-build/community-projects/scodec

@@ -124,7 +124,7 @@ object DottyBackendInterface {
     requiredModule(className)
   }
 
-  given symExtensions as AnyRef:
+  given symExtensions: AnyRef with
     extension (sym: Symbol):
 
       def isInterface(using Context): Boolean = (sym.is(PureInterface)) || sym.is(Trait)

community-build/community-projects/scodec-bits

@@ -942,7 +942,7 @@ final class JSExportsGen(jsCodeGen: JSCodeGen)(using Context) {
   private case object NoTypeTest extends RTTypeTest
 
   private object RTTypeTest {
-    given PartialOrdering[RTTypeTest] {
+    given PartialOrdering[RTTypeTest] with {
       override def tryCompare(lhs: RTTypeTest, rhs: RTTypeTest): Option[Int] = {
         if (lteq(lhs, rhs)) if (lteq(rhs, lhs)) Some(0) else Some(-1)
         else                if (lteq(rhs, lhs)) Some(1) else None

community-build/community-projects/shapeless

@@ -85,7 +85,7 @@ class Run(comp: Compiler, ictx: Context) extends ImplicitRunInfo with Constraint
   private var myCtx = rootContext(using ictx)
 
   /** The context created for this run */
-  given runContext[Dummy_so_its_a_def] as Context = myCtx
+  given runContext[Dummy_so_its_a_def]: Context = myCtx
   assert(runContext.runId <= Periods.MaxPossibleRunId)
 
   private var myUnits: List[CompilationUnit] = _

community-build/community-projects/xml-interpolator

@@ -1553,7 +1553,7 @@ object Trees {
     def applyOverloaded(
         receiver: tpd.Tree, method: TermName, args: List[Tree], targs: List[Type],
         expectedType: Type)(using parentCtx: Context): tpd.Tree = {
-      given ctx as Context = parentCtx.retractMode(Mode.ImplicitsEnabled)
+      given ctx: Context = parentCtx.retractMode(Mode.ImplicitsEnabled)
       import dotty.tools.dotc.ast.tpd.TreeOps
 
       val typer = ctx.typer

compiler/src/dotty/tools/backend/jvm/DottyBackendInterface.scala

@@ -15,7 +15,7 @@ object Comments {
   val ContextDoc: Key[ContextDocstrings] = new Key[ContextDocstrings]
 
   /** Decorator for getting docbase out of context */
-  given CommentsContext as AnyRef:
+  given CommentsContext: AnyRef with
     extension (c: Context) def docCtx: Option[ContextDocstrings] = c.property(ContextDoc)
 
   /** Context for Docstrings, contains basic functionality for getting

compiler/src/dotty/tools/backend/sjs/JSExportsGen.scala

@@ -649,7 +649,7 @@ object Contexts {
     def setDebug: this.type = setSetting(base.settings.Ydebug, true)
   }
 
-  given ops as AnyRef:
+  given ops: AnyRef with
     extension (c: Context):
       def addNotNullInfo(info: NotNullInfo) =
         c.withNotNullInfos(c.notNullInfos.extendWith(info))

compiler/src/dotty/tools/dotc/Run.scala

@@ -38,7 +38,7 @@ class Definitions {
   import Definitions._
 
   private var initCtx: Context = _
-  private given currentContext[Dummy_so_its_a_def] as Context = initCtx
+  private given currentContext[Dummy_so_its_a_def]: Context = initCtx
 
   private def newPermanentSymbol[N <: Name](owner: Symbol, name: N, flags: FlagSet, info: Type) =
     newSymbol(owner, name, flags | Permanent, info)

compiler/src/dotty/tools/dotc/ast/Trees.scala

@@ -34,7 +34,7 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
   private var myContext: Context = initctx
   def comparerContext: Context = myContext
 
-  protected given [DummySoItsADef] as Context = myContext
+  protected given [DummySoItsADef]: Context = myContext
 
   protected var state: TyperState = null
   def constraint: Constraint = state.constraint

compiler/src/dotty/tools/dotc/core/Comments.scala

@@ -913,7 +913,7 @@ object Parsers {
           lookahead.nextToken()
           skipParams()
       skipParams()
-      lookahead.token == COLON || lookahead.isIdent(nme.as)
+      lookahead.token == COLON
 
     def followingIsExtension() =
       val next = in.lookahead.token
@@ -3517,9 +3517,8 @@ object Parsers {
      */
     def givenDef(start: Offset, mods: Modifiers, givenMod: Mod) = atSpan(start, nameStart) {
       var mods1 = addMod(mods, givenMod)
-      val hasGivenSig = followingIsGivenSig()
       val nameStart = in.offset
-      val name = if isIdent && hasGivenSig then ident() else EmptyTermName
+      val name = if isIdent && followingIsGivenSig() then ident() else EmptyTermName
 
       val gdef =
         val tparams = typeParamClauseOpt(ParamOwner.Def)
@@ -3530,10 +3529,7 @@ object Parsers {
           else Nil
         newLinesOpt()
         val noParams = tparams.isEmpty && vparamss.isEmpty
-        val newSyntax = in.token == COLON
-        if !(name.isEmpty && noParams) then
-          if isIdent(nme.as) then in.nextToken()
-          else accept(COLON)
+        if !(name.isEmpty && noParams) then accept(COLON)
         val parents = constrApp() :: withConstrApps()
         val parentsIsType = parents.length == 1 && parents.head.isType
         if in.token == EQUALS && parentsIsType then
@@ -3544,22 +3540,16 @@ object Parsers {
             ValDef(name, parents.head, subExpr())
           else
             DefDef(name, tparams, vparamss, parents.head, subExpr())
-        else if newSyntax && in.token != WITH && in.token != WITHEOL && parentsIsType then
+        else if in.token != WITH && in.token != WITHEOL && parentsIsType then
           if name.isEmpty then
             syntaxError(em"anonymous given cannot be abstract")
           DefDef(name, tparams, vparamss, parents.head, EmptyTree)
         else
           val tparams1 = tparams.map(tparam => tparam.withMods(tparam.mods | PrivateLocal))
           val vparamss1 = vparamss.map(_.map(vparam =>
             vparam.withMods(vparam.mods &~ Param | ParamAccessor | Protected)))
-          val constr = makeConstructor(tparams1, vparamss1)
-          val templ =
-            if newSyntax || in.token == WITHEOL || in.token == WITH then
-              withTemplate(constr, parents)
-            else
-              possibleTemplateStart()
-              templateBodyOpt(makeConstructor(tparams1, vparamss1), parents, Nil)
-          if tparams.isEmpty && vparamss.isEmpty then ModuleDef(name, templ)
+          val templ = withTemplate(makeConstructor(tparams1, vparamss1), parents)
+          if noParams then ModuleDef(name, templ)
           else TypeDef(name.toTypeName, templ)
       end gdef
       finalizeDef(gdef, mods1, start)

compiler/src/dotty/tools/dotc/core/Contexts.scala

@@ -21,7 +21,7 @@ class PlainPrinter(_ctx: Context) extends Printer {
    *  Overridden in RefinedPrinter.
    */
   protected def curCtx: Context = _ctx.addMode(Mode.Printing)
-  protected given [DummyToEnforceDef] as Context = curCtx
+  protected given [DummyToEnforceDef]: Context = curCtx
 
   protected def printDebug = ctx.settings.YprintDebug.value
 
@@ -39,7 +39,7 @@ class PlainPrinter(_ctx: Context) extends Printer {
     limiter.register(str)
     Texts.Str(str, lineRange)
 
-  given stringToText as Conversion[String, Text] = Str(_)
+  given stringToText: Conversion[String, Text] = Str(_)
 
   /** If true, tweak output so it is the same before and after pickling */
   protected def homogenizedView: Boolean = ctx.settings.YtestPickler.value

compiler/src/dotty/tools/dotc/core/Definitions.scala

@@ -68,7 +68,7 @@ object Scala3:
   end Symbols
 
 
-  given NameOps as AnyRef:
+  given NameOps: AnyRef with
     extension (name: Name):
       def isWildcard = name match
         case nme.WILDCARD | WILDCARDTypeName => true
@@ -89,7 +89,7 @@ object Scala3:
         }
   end NameOps
 
-  given SymbolOps as AnyRef:
+  given SymbolOps: AnyRef with
     extension (sym: Symbol):
 
       def ifExists(using Context): Option[Symbol] = if sym.exists then Some(sym) else None
@@ -145,7 +145,7 @@ object Scala3:
       case '/' | '.' | '#' | ']' | ')' => true
       case _                           => false
 
-  given StringOps as AnyRef:
+  given StringOps: AnyRef with
     extension (symbol: String):
       def isSymbol: Boolean = !symbol.isEmpty
       def isRootPackage: Boolean = RootPackage == symbol
@@ -169,7 +169,7 @@ object Scala3:
         isJavaIdentifierStart(symbol.head) && symbol.tail.forall(isJavaIdentifierPart)
   end StringOps
 
-  given InfoOps as AnyRef:
+  given InfoOps: AnyRef with
     extension (info: SymbolInformation):
       def isAbstract: Boolean = (info.properties & SymbolInformation.Property.ABSTRACT.value) != 0
       def isFinal: Boolean = (info.properties & SymbolInformation.Property.FINAL.value) != 0
@@ -204,13 +204,13 @@ object Scala3:
       def isInterface: Boolean = info.kind.isInterface
   end InfoOps
 
-  given RangeOps as AnyRef:
+  given RangeOps: AnyRef with
     extension (range: Range):
       def hasLength = range.endLine > range.startLine || range.endCharacter > range.startCharacter
   end RangeOps
 
   /** Sort symbol occurrences by their start position. */
-  given OccurrenceOrdering as Ordering[SymbolOccurrence] = (x, y) =>
+  given OccurrenceOrdering: Ordering[SymbolOccurrence] = (x, y) =>
     x.range -> y.range match
     case None -> _ | _ -> None => 0
     case Some(a) -> Some(b) =>

compiler/src/dotty/tools/dotc/core/TypeComparer.scala

@@ -353,7 +353,7 @@ object ExplicitOuter {
    */
   class OuterOps(val ictx: Context) extends AnyVal {
     /** The context of all operations of this class */
-    given [Dummy] as Context = ictx
+    given [Dummy]: Context = ictx
 
     /** If `cls` has an outer parameter add one to the method type `tp`. */
     def addParam(cls: ClassSymbol, tp: Type): Type =

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

@@ -125,11 +125,11 @@ trait Deriving {
         //
         //     ADT: C[A, B]               (A, B have same kinds at T, U)
         //
-        //          given derived$TC      as TC[              C         ]  // a "natural" instance
+        //          given derived$TC      : TC[              C         ]  // a "natural" instance
         //
         //     ADT: C[A]                  (A has same kind as U)
         //
-        //          given derived$TC      as TC[[t, u] =>>    C[      u]]
+        //          given derived$TC      : TC[[t, u] =>>    C[      u]]
         //
         // (b) The type class and all ADT type parameters are of kind *
         //

compiler/src/dotty/tools/dotc/printing/PlainPrinter.scala

@@ -669,7 +669,7 @@ class Namer { typer: Typer =>
     protected def localContext(owner: Symbol): FreshContext = ctx.fresh.setOwner(owner).setTree(original)
 
     /** The context with which this completer was created */
-    given creationContext as Context = ictx
+    given creationContext: Context = ictx
 
     // make sure testing contexts are not captured by completers
     assert(!ictx.reporter.isInstanceOf[ExploringReporter])
@@ -835,7 +835,7 @@ class Namer { typer: Typer =>
 
     override final def typeSig(sym: Symbol): Type =
       val tparamSyms = completerTypeParams(sym)(using ictx)
-      given ctx as Context = nestedCtx
+      given ctx: Context = nestedCtx
 
       def abstracted(tp: TypeBounds): TypeBounds =
         HKTypeLambda.boundsFromParams(tparamSyms, tp)

compiler/src/dotty/tools/dotc/semanticdb/Scala3.scala

@@ -236,7 +236,7 @@ object PrepareInlineable {
         if (!ctx.isAfterTyper) {
           val inlineCtx = ctx
           inlined.updateAnnotation(LazyBodyAnnotation {
-            given ctx as Context = inlineCtx
+            given ctx: Context = inlineCtx
             var inlinedBody = dropInlineIfError(inlined, treeExpr)
             if inlined.isInlineMethod then
               inlinedBody = dropInlineIfError(inlined,

compiler/src/dotty/tools/dotc/transform/ExplicitOuter.scala

@@ -174,7 +174,7 @@ class ReplCompilerTests extends ReplTest {
         |  extension (x: T) def > (y: T) = compare(x, y) > 0
         |}
         |
-        |given IntOrd as Ord[Int] {
+        |given IntOrd: Ord[Int] with {
         |  def compare(x: Int, y: Int) =
         |  if (x < y) -1 else if (x > y) +1 else 0
         |}

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

@@ -32,7 +32,7 @@ title: "Erased Terms Spec"
 
 3. Functions
    * `(erased x1: T1, x2: T2, ..., xN: TN) => y : (erased T1, T2, ..., TN) => R`
-   * `(given erased x1: T1, x2: T2, ..., xN: TN) => y as (given erased T1, T2, ..., TN) => R`
+   * `(given erased x1: T1, x2: T2, ..., xN: TN) => y: (given erased T1, T2, ..., TN) => R`
    * `(given erased T1) => R  <:<  erased T1 => R`
    * `(given erased T1, T2) => R  <:< (erased T1, T2) => R`
    *  ...

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

@@ -361,7 +361,7 @@ class CompletionTest {
   @Test def completeExtensionMethodFromGivenInstanceDefinedInScope: Unit = {
     code"""object Foo
           |trait FooOps
-          |given FooOps {
+          |given FooOps with {
           |  extension (foo: Foo.type) def xxxx = 1
           |}
           |object Main { Foo.xx${m1} }""".withSource
@@ -372,7 +372,7 @@ class CompletionTest {
     code"""object Foo
           |trait FooOps
           |object Bar {
-          |  given FooOps {
+          |  given FooOps with {
           |    extension (foo: Foo.type) def xxxx = 1
           |  }
           |}
@@ -394,7 +394,7 @@ class CompletionTest {
     code"""trait Bar
           |case class Foo(i: Int)
           |object Foo {
-          |  given Bar {
+          |  given Bar with {
           |    extension (foo: Foo) def xxxx = foo.i
           |  }
           |}