Convert core classes (4)

Author: odersky

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

@@ -66,7 +66,7 @@ class Run(comp: Compiler, ictx: Context) extends ImplicitRunInfo with Constraint
     val bootstrap = ctx.fresh
       .setPeriod(Period(comp.nextRunId, FirstPhaseId))
       .setScope(rootScope)
-    rootScope.enter(ctx.definitions.RootPackage)(bootstrap)
+    rootScope.enter(ctx.definitions.RootPackage)(using bootstrap)
     val start = bootstrap.fresh
       .setOwner(defn.RootClass)
       .setTyper(new Typer)

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

@@ -1,6 +1,6 @@
 package dotty.tools.dotc.core
 
-import dotty.tools.dotc.core.Contexts.Context
+import dotty.tools.dotc.core.Contexts.{Context, ctx}
 import dotty.tools.dotc.core.Flags.JavaDefined
 import dotty.tools.dotc.core.StdNames.{jnme, nme}
 import dotty.tools.dotc.core.Symbols._
@@ -52,7 +52,7 @@ object JavaNullInterop {
    *
    *  But the selection can throw an NPE if the returned value is `null`.
    */
-  def nullifyMember(sym: Symbol, tp: Type, isEnumValueDef: Boolean)(implicit ctx: Context): Type = {
+  def nullifyMember(sym: Symbol, tp: Type, isEnumValueDef: Boolean)(using Context): Type = {
     assert(ctx.explicitNulls)
     assert(sym.is(JavaDefined), "can only nullify java-defined members")
 
@@ -70,20 +70,20 @@ object JavaNullInterop {
       nullifyType(tp)
   }
 
-  private def hasNotNullAnnot(sym: Symbol)(implicit ctx: Context): Boolean =
+  private def hasNotNullAnnot(sym: Symbol)(using Context): Boolean =
     ctx.definitions.NotNullAnnots.exists(nna => sym.unforcedAnnotation(nna).isDefined)
 
   /** If tp is a MethodType, the parameters and the inside of return type are nullified,
    *  but the result return type is not nullable.
    *  If tp is a type of a field, the inside of the type is nullified,
    *  but the result type is not nullable.
    */
-  private def nullifyExceptReturnType(tp: Type)(implicit ctx: Context): Type =
-    new JavaNullMap(true)(ctx)(tp)
+  private def nullifyExceptReturnType(tp: Type)(using Context): Type =
+    new JavaNullMap(true)(tp)
 
   /** Nullifies a Java type by adding `| UncheckedNull` in the relevant places. */
-  private def nullifyType(tp: Type)(implicit ctx: Context): Type =
-    new JavaNullMap(false)(ctx)(tp)
+  private def nullifyType(tp: Type)(using Context): Type =
+    new JavaNullMap(false)(tp)
 
   /** A type map that implements the nullification function on types. Given a Java-sourced type, this adds `| UncheckedNull`
    *  in the right places to make the nulls explicit in Scala.
@@ -96,7 +96,7 @@ object JavaNullInterop {
    *                                       This is useful for e.g. constructors, and also so that `A & B` is nullified
    *                                       to `(A & B) | UncheckedNull`, instead of `(A|UncheckedNull & B|UncheckedNull) | UncheckedNull`.
    */
-  private class JavaNullMap(var outermostLevelAlreadyNullable: Boolean)(implicit ctx: Context) extends TypeMap {
+  private class JavaNullMap(var outermostLevelAlreadyNullable: Boolean)(using Context) extends TypeMap {
     /** Should we nullify `tp` at the outermost level? */
     def needsNull(tp: Type): Boolean =
       !outermostLevelAlreadyNullable && (tp match {

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

@@ -12,14 +12,14 @@ object MacroClassLoader {
   private val MacroClassLoaderKey = new Property.Key[ClassLoader]
 
   /** Get the macro class loader */
-  def fromContext(implicit ctx: Context): ClassLoader =
+  def fromContext(using Context): ClassLoader =
     ctx.property(MacroClassLoaderKey).getOrElse(makeMacroClassLoader)
 
   /** Context with a cached macro class loader that can be accessed with `macroClassLoader` */
   def init(ctx: FreshContext): ctx.type =
-    ctx.setProperty(MacroClassLoaderKey, makeMacroClassLoader(ctx))
+    ctx.setProperty(MacroClassLoaderKey, makeMacroClassLoader(using ctx))
 
-  private def makeMacroClassLoader(implicit ctx: Context): ClassLoader = trace("new macro class loader") {
+  private def makeMacroClassLoader(using Context): ClassLoader = trace("new macro class loader") {
     val urls = ctx.settings.classpath.value.split(java.io.File.pathSeparatorChar).map(cp => java.nio.file.Paths.get(cp).toUri.toURL)
     val out = ctx.settings.outputDir.value.jpath.toUri.toURL // to find classes in case of suspended compilation
     new java.net.URLClassLoader(urls :+ out, getClass.getClassLoader)

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

@@ -6,7 +6,7 @@ import Names._
 import NameOps._
 import StdNames._
 import NameTags._
-import Contexts.Context
+import Contexts.{Context, ctx}
 import collection.mutable
 
 import scala.annotation.internal.sharable
@@ -214,11 +214,11 @@ object NameKinds {
     }
 
     /** Generate fresh unique term name of this kind with given prefix name */
-    def fresh(prefix: TermName = EmptyTermName)(implicit ctx: Context): TermName =
+    def fresh(prefix: TermName = EmptyTermName)(using Context): TermName =
       ctx.compilationUnit.freshNames.newName(prefix, this)
 
     /** Generate fresh unique type name of this kind with given prefix name */
-    def fresh(prefix: TypeName)(implicit ctx: Context): TypeName =
+    def fresh(prefix: TypeName)(using Context): TypeName =
       fresh(prefix.toTermName).toTypeName
 
     uniqueNameKinds(separator) = this

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

@@ -150,7 +150,7 @@ object NameOps {
      *  This is the fully qualified name of `base` with `ExpandPrefixName` as separator,
      *  followed by `kind` and the name.
      */
-    def expandedName(base: Symbol, kind: QualifiedNameKind = ExpandedName)(implicit ctx: Context): N =
+    def expandedName(base: Symbol, kind: QualifiedNameKind = ExpandedName)(using Context): N =
       likeSpacedN { base.fullNameSeparated(ExpandPrefixName, kind, name) }
 
     /** Revert the expanded name. */
@@ -160,7 +160,7 @@ object NameOps {
 
     def errorName: N = likeSpacedN(name ++ nme.ERROR)
 
-    def freshened(implicit ctx: Context): N = likeSpacedN {
+    def freshened(using Context): N = likeSpacedN {
       name.toTermName match {
         case ModuleClassName(original) => ModuleClassName(original.freshened)
         case name => UniqueName.fresh(name)
@@ -230,7 +230,7 @@ object NameOps {
       case nme.clone_ => nme.clone_
     }
 
-    def specializedFor(classTargs: List[Type], classTargsNames: List[Name], methodTargs: List[Type], methodTarsNames: List[Name])(implicit ctx: Context): N = {
+    def specializedFor(classTargs: List[Type], classTargsNames: List[Name], methodTargs: List[Type], methodTarsNames: List[Name])(using Context): N = {
 
       val methodTags: Seq[Name] = (methodTargs zip methodTarsNames).sortBy(_._2).map(x => defn.typeTag(x._1))
       val classTags: Seq[Name] = (classTargs zip classTargsNames).sortBy(_._2).map(x => defn.typeTag(x._1))
@@ -241,7 +241,7 @@ object NameOps {
     }
 
     /** If name length exceeds allowable limit, replace part of it by hash */
-    def compactified(implicit ctx: Context): TermName = termName(compactify(name.toString))
+    def compactified(using Context): TermName = termName(compactify(name.toString))
 
     def unmangleClassName: N = name.toTermName match {
       case name: SimpleName

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

@@ -1,6 +1,6 @@
 package dotty.tools.dotc.core
 
-import dotty.tools.dotc.core.Contexts.Context
+import dotty.tools.dotc.core.Contexts.{Context, ctx}
 import dotty.tools.dotc.core.Symbols.defn
 import dotty.tools.dotc.core.Types._
 
@@ -9,7 +9,7 @@ object NullOpsDecorator {
 
   implicit class NullOps(val self: Type) {
     /** Is this type exactly `UncheckedNull` (no vars, aliases, refinements etc allowed)? */
-    def isUncheckedNullType(implicit ctx: Context): Boolean = {
+    def isUncheckedNullType(using Context): Boolean = {
       assert(ctx.explicitNulls)
       // We can't do `self == defn.UncheckedNull` because when trees are unpickled new references
       // to `UncheckedNull` could be created that are different from `defn.UncheckedNull`.
@@ -24,7 +24,7 @@ object NullOpsDecorator {
      *
      *  @param onlyUncheckedNull whether we only remove `UncheckedNull`, the default value is false
      */
-    def stripNull(onlyUncheckedNull: Boolean = false)(implicit ctx: Context): Type = {
+    def stripNull(onlyUncheckedNull: Boolean = false)(using Context): Type = {
       assert(ctx.explicitNulls)
 
       def isNull(tp: Type) =
@@ -56,14 +56,14 @@ object NullOpsDecorator {
     }
 
     /** Like `stripNull`, but removes only the `UncheckedNull`s. */
-    def stripUncheckedNull(implicit ctx: Context): Type = self.stripNull(true)
+    def stripUncheckedNull(using Context): Type = self.stripNull(true)
 
     /** Collapses all `UncheckedNull` unions within this type, and not just the outermost ones (as `stripUncheckedNull` does).
      *  e.g. (Array[String|UncheckedNull]|UncheckedNull).stripUncheckedNull => Array[String|UncheckedNull]
      *       (Array[String|UncheckedNull]|UncheckedNull).stripAllUncheckedNull => Array[String]
      *  If no `UncheckedNull` unions are found within the type, then returns the input type unchanged.
      */
-    def stripAllUncheckedNull(implicit ctx: Context): Type = {
+    def stripAllUncheckedNull(using Context): Type = {
       object RemoveNulls extends TypeMap {
         override def apply(tp: Type): Type = mapOver(tp.stripNull(true))
       }
@@ -72,13 +72,13 @@ object NullOpsDecorator {
     }
 
     /** Is self (after widening and dealiasing) a type of the form `T | Null`? */
-    def isNullableUnion(implicit ctx: Context): Boolean = {
+    def isNullableUnion(using Context): Boolean = {
       val stripped = self.stripNull()
       stripped ne self
     }
 
     /** Is self (after widening and dealiasing) a type of the form `T | UncheckedNull`? */
-    def isUncheckedNullableUnion(implicit ctx: Context): Boolean = {
+    def isUncheckedNullableUnion(using Context): Boolean = {
       val stripped = self.stripNull(true)
       stripped ne self
     }