Fix rebase breakage and other tweaks

Author: odersky

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

@@ -88,7 +88,7 @@ object Contexts {
        with Plugins
        with Cloneable { thiscontext =>
 
-    implicit def thisContext: Context = this
+    given Context = this
 
     /** All outer contexts, ending in `base.initialCtx` and then `NoContext` */
     def outersIterator: Iterator[Context] = new Iterator[Context] {

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

@@ -158,7 +158,7 @@ object Inliner {
 
     val unappplySym = ctx.newSymbol(cls, sym.name.toTermName, Synthetic | Method, unapplyInfo, coord = sym.coord).entered
     val unapply = DefDef(unappplySym, argss =>
-      inlineCall(fun.appliedToArgss(argss).withSpan(unapp.span))(ctx.withOwner(unappplySym))
+      inlineCall(fun.appliedToArgss(argss).withSpan(unapp.span))(using ctx.withOwner(unappplySym))
     )
     val cdef = ClassDef(cls, DefDef(constr), List(unapply))
     val newUnapply = Block(cdef :: Nil, New(cls.typeRef, Nil))

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

@@ -39,13 +39,11 @@ trait NamerContextOps {
    *  in order to make sure that updates to class members are reflected in
    *  finger prints.
    */
-  def enter(sym: Symbol): Symbol = {
-    thisContext.owner match {
+  def enter(sym: Symbol): Symbol =
+    thisCtx.owner match
       case cls: ClassSymbol => cls.enter(sym)
       case _ => thisCtx.scope.openForMutations.enter(sym)
-    }
     sym
-  }
 
   /** The denotation with the given `name` and all `required` flags in current context
    */

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

@@ -67,23 +67,23 @@ object ProtoTypes {
      */
     def constrainResult(mt: Type, pt: Type)(using Context): Boolean =
       inContext(ctx.addMode(Mode.ConstrainResult)) {
-      val savedConstraint = ctx.typerState.constraint
-      val res = pt.widenExpr match {
-        case pt: FunProto =>
-          mt match {
-            case mt: MethodType => constrainResult(resultTypeApprox(mt), pt.resultType)
-            case _ => true
-          }
-        case _: ValueTypeOrProto if !disregardProto(pt) =>
-          isCompatible(normalize(mt, pt), pt)
-        case pt: WildcardType if pt.optBounds.exists =>
-          isCompatible(normalize(mt, pt), pt)
-        case _ =>
-          true
+        val savedConstraint = ctx.typerState.constraint
+        val res = pt.widenExpr match {
+          case pt: FunProto =>
+            mt match {
+              case mt: MethodType => constrainResult(resultTypeApprox(mt), pt.resultType)
+              case _ => true
+            }
+          case _: ValueTypeOrProto if !disregardProto(pt) =>
+            isCompatible(normalize(mt, pt), pt)
+          case pt: WildcardType if pt.optBounds.exists =>
+            isCompatible(normalize(mt, pt), pt)
+          case _ =>
+            true
+        }
+        if (!res) ctx.typerState.resetConstraintTo(savedConstraint)
+        res
       }
-      if (!res) ctx.typerState.resetConstraintTo(savedConstraint)
-      res
-    }
 
     /** Constrain result with special case if `meth` is an inlineable method in an inlineable context.
      *  In that case, we should always succeed and not constrain type parameters in the expected type,

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

@@ -351,7 +351,7 @@ class Typer extends Namer
                 if (defDenot.symbol.is(Package))
                   result = checkNewOrShadowed(previous orElse found, PackageClause)
                 else if (prevPrec.ordinal < PackageClause.ordinal)
-                  result = findRefRecur(found, PackageClause, ctx)(ctx.outer)
+                  result = findRefRecur(found, PackageClause, ctx)(using ctx.outer)
             }
 
           if result.exists then result