Convert core classes (6)

Author: odersky

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

@@ -24,7 +24,7 @@ object Uniques {
       record(s"cached: $clazz")
     }
 
-  def unique[T <: Type](tp: T)(implicit ctx: Context): T = {
+  def unique[T <: Type](tp: T)(using Context): T = {
     if (monitored) recordCaching(tp)
     if (tp.hash == NotCached) tp
     else if (monitored) {
@@ -56,7 +56,7 @@ object Uniques {
       e
     }
 
-    def enterIfNew(prefix: Type, designator: Designator, isTerm: Boolean)(implicit ctx: Context): NamedType = {
+    def enterIfNew(prefix: Type, designator: Designator, isTerm: Boolean)(using Context): NamedType = {
       val h = doHash(null, designator, prefix)
       if (monitored) recordCaching(h, classOf[NamedType])
       def newType =

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

@@ -37,22 +37,22 @@ object Variances {
     else cut(v)
 
   /** Compute variance of type parameter `tparam` in types of all symbols `sym`. */
-  def varianceInSyms(syms: List[Symbol])(tparam: Symbol)(implicit ctx: Context): Variance =
+  def varianceInSyms(syms: List[Symbol])(tparam: Symbol)(using Context): Variance =
     syms.foldLeft(Bivariant) ((v, sym) => v & varianceInSym(sym)(tparam))
 
   /** Compute variance of type parameter `tparam` in type of symbol `sym`. */
-  def varianceInSym(sym: Symbol)(tparam: Symbol)(implicit ctx: Context): Variance =
+  def varianceInSym(sym: Symbol)(tparam: Symbol)(using Context): Variance =
     if (sym.isAliasType) cut(varianceInType(sym.info)(tparam))
     else varianceInType(sym.info)(tparam)
 
   /** Compute variance of type parameter `tparam` in all types `tps`. */
-  def varianceInTypes(tps: List[Type])(tparam: Symbol)(implicit ctx: Context): Variance =
+  def varianceInTypes(tps: List[Type])(tparam: Symbol)(using Context): Variance =
     tps.foldLeft(Bivariant) ((v, tp) => v & varianceInType(tp)(tparam))
 
   /** Compute variance of type parameter `tparam` in all type arguments
    *  <code>tps</code> which correspond to formal type parameters `tparams1`.
    */
-  def varianceInArgs(tps: List[Type], tparams1: List[Symbol])(tparam: Symbol)(implicit ctx: Context): Variance = {
+  def varianceInArgs(tps: List[Type], tparams1: List[Symbol])(tparam: Symbol)(using Context): Variance = {
     var v: Variance = Bivariant;
     for ((tp, tparam1) <- tps zip tparams1) {
       val v1 = varianceInType(tp)(tparam)
@@ -64,15 +64,15 @@ object Variances {
   }
 
   /** Compute variance of type parameter `tparam` in all type annotations `annots`. */
-  def varianceInAnnots(annots: List[Annotation])(tparam: Symbol)(implicit ctx: Context): Variance =
+  def varianceInAnnots(annots: List[Annotation])(tparam: Symbol)(using Context): Variance =
     annots.foldLeft(Bivariant) ((v, annot) => v & varianceInAnnot(annot)(tparam))
 
   /** Compute variance of type parameter `tparam` in type annotation `annot`. */
-  def varianceInAnnot(annot: Annotation)(tparam: Symbol)(implicit ctx: Context): Variance =
+  def varianceInAnnot(annot: Annotation)(tparam: Symbol)(using Context): Variance =
     varianceInType(annot.tree.tpe)(tparam)
 
   /** Compute variance of type parameter <code>tparam</code> in type <code>tp</code>. */
-  def varianceInType(tp: Type)(tparam: Symbol)(implicit ctx: Context): Variance = tp match {
+  def varianceInType(tp: Type)(tparam: Symbol)(using Context): Variance = tp match {
     case TermRef(pre, _) =>
       varianceInType(pre)(tparam)
     case tp @ TypeRef(pre, _) =>
@@ -109,7 +109,7 @@ object Variances {
       Bivariant
   }
 
-  def setStructuralVariances(lam: HKTypeLambda)(implicit ctx: Context): Unit =
+  def setStructuralVariances(lam: HKTypeLambda)(using Context): Unit =
     assert(!lam.isDeclaredVarianceLambda)
     for param <- lam.typeParams do param.storedVariance = Bivariant
     object narrowVariances extends TypeTraverser {
@@ -132,22 +132,22 @@ object Variances {
 
   /** Does the variance of type parameter `tparam1` conform to the variance of type parameter `tparam2`?
    */
-   def varianceConforms(tparam1: TypeParamInfo, tparam2: TypeParamInfo)(implicit ctx: Context): Boolean =
+   def varianceConforms(tparam1: TypeParamInfo, tparam2: TypeParamInfo)(using Context): Boolean =
     tparam1.paramVariance.isAllOf(tparam2.paramVariance)
 
   /** Do the variances of type parameters `tparams1` conform to the variances
    *  of corresponding type parameters `tparams2`?
    *  This is only the case if `tparams1` and `tparams2` have the same length.
    */
-  def variancesConform(tparams1: List[TypeParamInfo], tparams2: List[TypeParamInfo])(implicit ctx: Context): Boolean =
+  def variancesConform(tparams1: List[TypeParamInfo], tparams2: List[TypeParamInfo])(using Context): Boolean =
     val needsDetailedCheck = tparams2 match
       case (_: Symbol) :: _ => true
       case LambdaParam(tl: HKTypeLambda, _) :: _ => tl.isDeclaredVarianceLambda
       case _ => false
     if needsDetailedCheck then tparams1.corresponds(tparams2)(varianceConforms)
     else tparams1.hasSameLengthAs(tparams2)
 
-  def varianceSign(sym: Symbol)(implicit ctx: Context): String =
+  def varianceSign(sym: Symbol)(using Context): String =
     varianceSign(sym.variance)
 
   def varianceSign(v: Variance): String = varianceSign(varianceToInt(v))

compiler/src/dotty/tools/dotc/core/classfile/ClassfileParser.scala

@@ -32,7 +32,7 @@ object ClassfileParser {
   object NoEmbedded extends Embedded
 
   /** Replace raw types with wildcard applications */
-  def cook(implicit ctx: Context): TypeMap = new TypeMap {
+  def cook(using Context): TypeMap = new TypeMap {
     def apply(tp: Type): Type = tp match {
       case tp: TypeRef if tp.symbol.typeParams.nonEmpty =>
         AppliedType(tp, tp.symbol.typeParams.map(Function.const(TypeBounds.empty)))
@@ -77,12 +77,12 @@ class ClassfileParser(
   classRoot.info = NoLoader().withDecls(instanceScope)
   moduleRoot.info = NoLoader().withDecls(staticScope).withSourceModule(_ => staticModule)
 
-  private def currentIsTopLevel(implicit ctx: Context) = classRoot.owner.is(Flags.PackageClass)
+  private def currentIsTopLevel(using Context) = classRoot.owner.is(Flags.PackageClass)
 
   private def mismatchError(className: SimpleName) =
     throw new IOException(s"class file '${in.file.canonicalPath}' has location not matching its contents: contains class $className")
 
-  def run()(implicit ctx: Context): Option[Embedded] = try {
+  def run()(using Context): Option[Embedded] = try {
     ctx.debuglog("[class] >> " + classRoot.fullName)
     parseHeader()
     this.pool = new ConstantPool
@@ -110,14 +110,14 @@ class ClassfileParser(
   }
 
   /** Return the class symbol of the given name. */
-  def classNameToSymbol(name: Name)(implicit ctx: Context): Symbol = innerClasses.get(name) match {
+  def classNameToSymbol(name: Name)(using Context): Symbol = innerClasses.get(name) match {
     case Some(entry) => innerClasses.classSymbol(entry)
     case None => ctx.requiredClass(name)
   }
 
   var sawPrivateConstructor: Boolean = false
 
-  def parseClass()(implicit ctx: Context): Option[Embedded] = {
+  def parseClass()(using Context): Option[Embedded] = {
     val jflags       = in.nextChar
     val isAnnotation = hasAnnotation(jflags)
     val sflags       = classTranslation.flags(jflags)
@@ -207,7 +207,7 @@ class ClassfileParser(
   }
 
   /** Add type parameters of enclosing classes */
-  def addEnclosingTParams()(implicit ctx: Context): Unit = {
+  def addEnclosingTParams()(using Context): Unit = {
     var sym = classRoot.owner
     while (sym.isClass && !sym.is(Flags.ModuleClass)) {
       for (tparam <- sym.typeParams)
@@ -216,7 +216,7 @@ class ClassfileParser(
     }
   }
 
-  def parseMember(method: Boolean)(implicit ctx: Context): Unit = {
+  def parseMember(method: Boolean)(using Context): Unit = {
     val start = indexCoord(in.bp)
     val jflags = in.nextChar
     val sflags =
@@ -236,7 +236,7 @@ class ClassfileParser(
 
   val memberCompleter: LazyType = new LazyType {
 
-    def complete(denot: SymDenotation)(implicit ctx: Context): Unit = {
+    def complete(denot: SymDenotation)(using Context): Unit = {
       val oldbp = in.bp
       try {
         in.bp = denot.symbol.coord.toIndex
@@ -307,7 +307,7 @@ class ClassfileParser(
   }
 
   /** Map direct references to Object to references to Any */
-  final def objToAny(tp: Type)(implicit ctx: Context): Type =
+  final def objToAny(tp: Type)(using Context): Type =
     if (tp.isDirectRef(defn.ObjectClass) && !ctx.phase.erasedTypes) defn.AnyType else tp
 
   def constantTagToType(tag: Int)(using Context): Type =
@@ -323,7 +323,7 @@ class ClassfileParser(
       case BOOL_TAG   => defn.BooleanType
     }
 
-  private def sigToType(sig: SimpleName, owner: Symbol = null)(implicit ctx: Context): Type = {
+  private def sigToType(sig: SimpleName, owner: Symbol = null)(using Context): Type = {
     var index = 0
     val end = sig.length
     def accept(ch: Char): Unit = {
@@ -337,7 +337,7 @@ class ClassfileParser(
     }
     // Warning: sigToType contains nested completers which might be forced in a later run!
     // So local methods need their own ctx parameters.
-    def sig2type(tparams: immutable.Map[Name, Symbol], skiptvs: Boolean)(implicit ctx: Context): Type = {
+    def sig2type(tparams: immutable.Map[Name, Symbol], skiptvs: Boolean)(using Context): Type = {
       val tag = sig(index); index += 1
       (tag: @switch) match {
         case 'L' =>
@@ -415,7 +415,7 @@ class ClassfileParser(
     }
     // sig2type(tparams, skiptvs)
 
-    def sig2typeBounds(tparams: immutable.Map[Name, Symbol], skiptvs: Boolean)(implicit ctx: Context): Type = {
+    def sig2typeBounds(tparams: immutable.Map[Name, Symbol], skiptvs: Boolean)(using Context): Type = {
       val ts = new ListBuffer[Type]
       while (sig(index) == ':') {
         index += 1
@@ -429,7 +429,7 @@ class ClassfileParser(
     var tparams = classTParams
 
     def typeParamCompleter(start: Int) = new LazyType {
-      def complete(denot: SymDenotation)(implicit ctx: Context): Unit = {
+      def complete(denot: SymDenotation)(using Context): Unit = {
         val savedIndex = index
         try {
           index = start
@@ -476,7 +476,7 @@ class ClassfileParser(
   }
   // sigToType
 
-  def parseAnnotArg(skip: Boolean = false)(implicit ctx: Context): Option[untpd.Tree] = {
+  def parseAnnotArg(skip: Boolean = false)(using Context): Option[untpd.Tree] = {
 
     // If we encounter an empty array literal, we need the type of the corresponding
     // parameter to properly type it, but that would require forcing the annotation
@@ -534,7 +534,7 @@ class ClassfileParser(
   /** Parse and return a single annotation.  If it is malformed,
    *  return None.
    */
-  def parseAnnotation(attrNameIndex: Char, skip: Boolean = false)(implicit ctx: Context): Option[Annotation] = try {
+  def parseAnnotation(attrNameIndex: Char, skip: Boolean = false)(using Context): Option[Annotation] = try {
     val attrType = pool.getType(attrNameIndex)
     attrType match
       case tp: TypeRef =>
@@ -573,7 +573,7 @@ class ClassfileParser(
       None // ignore malformed annotations
   }
 
-  def parseAttributes(sym: Symbol, symtype: Type)(implicit ctx: Context): Type = {
+  def parseAttributes(sym: Symbol, symtype: Type)(using Context): Type = {
     var newType = symtype
 
     def parseAttribute(): Unit = {
@@ -662,7 +662,7 @@ class ClassfileParser(
   /** Annotations in Scala are assumed to get all their arguments as constructor
    *  parameters. For Java annotations we need to fake it by making up the constructor.
    */
-  def addAnnotationConstructor(classInfo: TempClassInfoType)(implicit ctx: Context): Unit =
+  def addAnnotationConstructor(classInfo: TempClassInfoType)(using Context): Unit =
     ctx.newSymbol(
       owner = classRoot.symbol,
       name = nme.CONSTRUCTOR,
@@ -671,7 +671,7 @@ class ClassfileParser(
     ).entered
 
   class AnnotConstructorCompleter(classInfo: TempClassInfoType) extends LazyType {
-    def complete(denot: SymDenotation)(implicit ctx: Context): Unit = {
+    def complete(denot: SymDenotation)(using Context): Unit = {
       val attrs = classInfo.decls.toList.filter(sym => sym.isTerm && sym != denot.symbol)
       val paramNames = attrs.map(_.name.asTermName)
       val paramTypes = attrs.map(_.info.resultType)
@@ -682,7 +682,7 @@ class ClassfileParser(
   /** Enter own inner classes in the right scope. It needs the scopes to be set up,
    *  and implicitly current class' superclasses.
    */
-  private def enterOwnInnerClasses()(implicit ctx: Context): Unit = {
+  private def enterOwnInnerClasses()(using Context): Unit = {
     def className(name: Name): Name = {
       val name1 = name.toSimpleName
       name1.drop(name1.lastIndexOf('.') + 1)
@@ -715,7 +715,7 @@ class ClassfileParser(
    *  Restores the old `bp`.
    *  @return true iff classfile is from Scala, so no Java info needs to be read.
    */
-  def unpickleOrParseInnerClasses()(implicit ctx: Context): Option[Embedded] = {
+  def unpickleOrParseInnerClasses()(using Context): Option[Embedded] = {
     val oldbp = in.bp
     try {
       skipSuperclasses()
@@ -905,7 +905,7 @@ class ClassfileParser(
     /** Return the Symbol of the top level class enclosing `name`,
      *  or 'name's symbol if no entry found for `name`.
      */
-    def topLevelClass(name: Name)(implicit ctx: Context): Symbol = {
+    def topLevelClass(name: Name)(using Context): Symbol = {
       val tlName = if (isDefinedAt(name)) {
         var entry = this(name)
         while (isDefinedAt(entry.outerName))
@@ -920,8 +920,8 @@ class ClassfileParser(
     /** Return the class symbol for `entry`. It looks it up in its outer class.
      *  This might force outer class symbols.
      */
-    def classSymbol(entry: InnerClassEntry)(implicit ctx: Context): Symbol = {
-      def getMember(sym: Symbol, name: Name)(implicit ctx: Context): Symbol =
+    def classSymbol(entry: InnerClassEntry)(using Context): Symbol = {
+      def getMember(sym: Symbol, name: Name)(using Context): Symbol =
         if (isStatic(entry.jflags))
           if (sym == classRoot.symbol)
             staticScope.lookup(name)
@@ -977,7 +977,7 @@ class ClassfileParser(
   protected def getScope(flags: Int): MutableScope =
     if (isStatic(flags)) staticScope else instanceScope
 
-  private def getPrivateWithin(jflags: Int)(implicit ctx: Context): Symbol =
+  private def getPrivateWithin(jflags: Int)(using Context): Symbol =
     if ((jflags & (JAVA_ACC_PRIVATE | JAVA_ACC_PUBLIC)) == 0)
       classRoot.enclosingPackageClass
     else
@@ -1048,7 +1048,7 @@ class ClassfileParser(
       internalized(index)
     }
 
-    def getClassSymbol(index: Int)(implicit ctx: Context): Symbol = {
+    def getClassSymbol(index: Int)(using Context): Symbol = {
       if (index <= 0 || len <= index) errorBadIndex(index)
       var c = values(index).asInstanceOf[Symbol]
       if (c eq null) {
@@ -1077,7 +1077,7 @@ class ClassfileParser(
      *  arrays are considered to be class types, they might
      *  appear as entries in 'newarray' or 'cast' opcodes.
      */
-    def getClassOrArrayType(index: Int)(implicit ctx: Context): Type = {
+    def getClassOrArrayType(index: Int)(using Context): Type = {
       if (index <= 0 || len <= index) errorBadIndex(index)
       val value = values(index)
       var c: Type = null
@@ -1102,15 +1102,15 @@ class ClassfileParser(
       c
     }
 
-    def getType(index: Int)(implicit ctx: Context): Type =
+    def getType(index: Int)(using Context): Type =
       sigToType(getExternalName(index))
 
-    def getSuperClass(index: Int)(implicit ctx: Context): Symbol = {
+    def getSuperClass(index: Int)(using Context): Symbol = {
       assert(index != 0, "attempt to parse java.lang.Object from classfile")
       getClassSymbol(index)
     }
 
-    def getConstant(index: Int, pt: Type = WildcardType)(implicit ctx: Context): Constant = {
+    def getConstant(index: Int, pt: Type = WildcardType)(using Context): Constant = {
       if (index <= 0 || len <= index) errorBadIndex(index)
       var value = values(index)
       if (value eq null) {