More fixes in code and tests

Author: odersky

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

@@ -161,10 +161,10 @@ class GenBCodePipeline(val int: DottyBackendInterface)(implicit val ctx: Context
           val same = classSymbol.effectiveName.toString == dupClassSym.effectiveName.toString
           ctx.atPhase(ctx.typerPhase) {
             if (same)
-              the[Context].warning( // FIXME: This should really be an error, but then FromTasty tests fail
+              summon[Context].warning( // FIXME: This should really be an error, but then FromTasty tests fail
                 s"${cl1.show} and ${cl2.showLocated} produce classes that overwrite one another", cl1.sourcePos)
             else
-              the[Context].warning(s"${cl1.show} differs only in case from ${cl2.showLocated}. " +
+              summon[Context].warning(s"${cl1.show} differs only in case from ${cl2.showLocated}. " +
                 "Such classes will overwrite one another on case-insensitive filesystems.", cl1.sourcePos)
           }
       }

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

@@ -893,7 +893,7 @@ object desugar {
    *  If the given member `mdef` is not of this form, flag it as an error.
    */
 
-  def makeExtensionDef(mdef: Tree, tparams: List[TypeDef], leadingParams: List[ValDef]) given (ctx: Context): Tree = {
+  def makeExtensionDef(mdef: Tree, tparams: List[TypeDef], leadingParams: List[ValDef])(given ctx: Context): Tree = {
     val allowed = "allowed here, since collective parameters are given"
     mdef match {
       case mdef: DefDef =>

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

@@ -40,7 +40,7 @@ object MainProxies {
   }
 
   import untpd._
-  def mainProxy(mainFun: Symbol) given (ctx: Context): List[TypeDef] = {
+  def mainProxy(mainFun: Symbol)(given ctx: Context): List[TypeDef] = {
     val mainAnnotSpan = mainFun.getAnnotation(defn.MainAnnot).get.tree.span
     def pos = mainFun.sourcePos
     val argsRef = Ident(nme.args)

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

@@ -121,7 +121,7 @@ object Annotations {
     def deferred(sym: Symbol)(treeFn: ImplicitFunction1[Context, Tree])(implicit ctx: Context): Annotation =
       new LazyAnnotation {
         override def symbol(implicit ctx: Context): Symbol = sym
-        def complete(implicit ctx: Context) = treeFn given ctx
+        def complete(implicit ctx: Context) = treeFn(given ctx)
       }
 
     /** Create an annotation where the symbol and the tree are computed lazily. */
@@ -131,12 +131,12 @@ object Annotations {
 
         override def symbol(implicit ctx: Context): Symbol = {
           if (mySym == null || mySym.defRunId != ctx.runId) {
-            mySym = symf given ctx
+            mySym = symf(given ctx)
             assert(mySym != null)
           }
           mySym
         }
-        def complete(implicit ctx: Context) = treeFn given ctx
+        def complete(implicit ctx: Context) = treeFn(given ctx)
       }
 
     def deferred(atp: Type, args: List[Tree])(implicit ctx: Context): Annotation =

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

@@ -174,7 +174,7 @@ object Decorators {
     def (x: T) reporting[T](
         op: ImplicitFunction1[WrappedResult[T], String],
         printer: config.Printers.Printer = config.Printers.default): T = {
-      printer.println(op given WrappedResult(x))
+      printer.println(op(given WrappedResult(x)))
       x
     }
   }

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

@@ -22,7 +22,7 @@ abstract class Periods { self: Context =>
 
   /** Execute `op` at given phase id */
   def atPhase[T](pid: PhaseId)(op: ImplicitFunction1[Context, T]): T =
-    op given ctx.withPhase(pid)
+    op(given ctx.withPhase(pid))
 
   /** The period containing the current period where denotations do not change.
    *  We compute this by taking as first phase the first phase less or equal to

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

@@ -37,7 +37,7 @@ trait Phases {
   def atNextPhase[T](op: ImplicitFunction1[Context, T]): T = atPhase(phase.next)(op)
 
   def atPhaseNotLaterThan[T](limit: Phase)(op: ImplicitFunction1[Context, T]): T =
-    if (!limit.exists || phase <= limit) op given this else atPhase(limit)(op)
+    if (!limit.exists || phase <= limit) op(given this) else atPhase(limit)(op)
 
   def isAfterTyper: Boolean = base.isAfterTyper(phase)
 }

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

@@ -167,7 +167,7 @@ object Signature {
           y match {
             case y: TypeName =>
               // `Ordering[TypeName]` doesn't work due to `Ordering` still being invariant
-              the[Ordering[Name]].compare(x, y)
+              summon[Ordering[Name]].compare(x, y)
             case y: Int =>
               1
           }
@@ -184,7 +184,7 @@ object Signature {
       import scala.math.Ordering.Implicits.seqOrdering
       val paramsOrdering = seqOrdering(paramSigOrdering).compare(x.paramsSig, y.paramsSig)
       if (paramsOrdering != 0) paramsOrdering
-      else the[Ordering[Name]].compare(x.resSig, y.resSig)
+      else summon[Ordering[Name]].compare(x.resSig, y.resSig)
     }
   }
 }

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

@@ -195,7 +195,7 @@ class TypeComparer(initctx: Context) extends ConstraintHandling[AbsentContext] w
         //}
         assert(!ctx.settings.YnoDeepSubtypes.value)
         if (Config.traceDeepSubTypeRecursions && !this.isInstanceOf[ExplainingTypeComparer])
-          ctx.log(TypeComparer.explained(the[Context].typeComparer.isSubType(tp1, tp2, approx)))
+          ctx.log(TypeComparer.explained(summon[Context].typeComparer.isSubType(tp1, tp2, approx)))
       }
       // Eliminate LazyRefs before checking whether we have seen a type before
       val normalize = new TypeMap {
@@ -2309,7 +2309,7 @@ object TypeComparer {
   /** Show trace of comparison operations when performing `op` */
   def explaining[T](say: String => Unit)(op: ImplicitFunction1[Context, T])(implicit ctx: Context): T = {
     val nestedCtx = ctx.fresh.setTypeComparerFn(new ExplainingTypeComparer(_))
-    val res = try { op given nestedCtx } finally { say(nestedCtx.typeComparer.lastTrace()) }
+    val res = try { op(given nestedCtx) } finally { say(nestedCtx.typeComparer.lastTrace()) }
     res
   }
 

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

@@ -98,7 +98,7 @@ class TyperState(private val previous: TyperState /* | Null */) {
    */
   def test[T](op: ImplicitFunction1[Context, T])(implicit ctx: Context): T =
     if (isShared)
-      op given ctx.fresh.setExploreTyperState()
+      op(given ctx.fresh.setExploreTyperState())
     else {
       val savedConstraint = myConstraint
       val savedReporter = myReporter
@@ -113,7 +113,7 @@ class TyperState(private val previous: TyperState /* | Null */) {
         testReporter.inUse = true
         testReporter
       }
-      try op given ctx
+      try op(given ctx)
       finally {
         testReporter.inUse = false
         resetConstraintTo(savedConstraint)