diff --git a/src/dotty/tools/dotc/backend/jvm/BCodeBodyBuilder.scala b/src/dotty/tools/dotc/backend/jvm/BCodeBodyBuilder.scala index 1addc588fc43..b24723aa9690 100755 --- a/src/dotty/tools/dotc/backend/jvm/BCodeBodyBuilder.scala +++ b/src/dotty/tools/dotc/backend/jvm/BCodeBodyBuilder.scala @@ -241,7 +241,7 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder { def elementType = enteringTyper { val arrayParent = tpe :: tpe.parents collectFirst { - case dotc.core.Types.TypeRef(_, ArrayClass, elem :: Nil) => elem + case dotc.core.Types.TypeRef(_, ctx.definitions.ArrayClass, elem :: Nil) => elem } arrayParent getOrElse sys.error(fun.fullName + " : " + (tpe :: tpe.baseTypeSeq.toList).mkString(", ")) } @@ -353,7 +353,7 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder { case lblDf : LabelDef => genLabelDef(lblDf, expectedType) case ValDef(_, nme.THIS, _, _) => - debuglog("skipping trivial assign to _$this: " + tree) + ctx.debuglog("skipping trivial assign to _$this: " + tree) case ValDef(_, _, _, rhs) => val sym = tree.symbol @@ -400,7 +400,7 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder { else { mnode.visitVarInsn(asm.Opcodes.ALOAD, 0) generatedType = - if (tree.symbol == ArrayClass) ObjectReference + if (tree.symbol == ctx.definitions.ArrayClass) ObjectReference else brefType(thisName) // inner class (if any) for claszSymbol already tracked. } @@ -412,7 +412,7 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder { val sym = tree.symbol generatedType = symInfoTK(sym) val hostClass = findHostClass(qualifier.tpe, sym) - debuglog(s"Host class of $sym with qual $qualifier (${qualifier.tpe}) is $hostClass") + ctx.debuglog(s"Host class of $sym with qual $qualifier (${qualifier.tpe}) is $hostClass") val qualSafeToElide = treeInfo isQualifierSafeToElide qualifier def genLoadQualUnlessElidable(): Unit = { if (!qualSafeToElide) { genLoadQualifier(tree) } } @@ -440,11 +440,12 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder { } case Literal(value) => + import core.Constants._ if (value.tag != UnitTag) (value.tag, expectedType) match { - case (dotc.core.Constants.IntTag, LONG ) => bc.lconst(value.longValue); generatedType = LONG - case (dotc.core.Constants.FloatTag, DOUBLE) => bc.dconst(value.doubleValue); generatedType = DOUBLE - case (dotc.core.Constants.NullTag, _ ) => bc.emit(asm.Opcodes.ACONST_NULL); generatedType = RT_NULL - case _ => genConstant(value); generatedType = tpeTK(tree) + case (IntTag, LONG ) => bc.lconst(value.longValue); generatedType = LONG + case (FloatTag, DOUBLE) => bc.dconst(value.doubleValue); generatedType = DOUBLE + case (NullTag, _ ) => bc.emit(asm.Opcodes.ACONST_NULL); generatedType = RT_NULL + case _ => genConstant(value); generatedType = tpeTK(tree) } case blck : Block => genBlock(blck, expectedType) @@ -517,7 +518,7 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder { */ def genConstant(const: Constant): Unit = { - import dotc.core.Constants._ + import core.Constants._ (const.tag: @switch) match { @@ -587,7 +588,10 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder { case nextCleanup :: rest => if (saveReturnValue) { if (insideCleanupBlock) { - cunit.warning(r.pos, "Return statement found in finally-clause, discarding its return-value in favor of that of a more deeply nested return.") + ctx.warning( + "Return statement found in finally-clause, discarding its return-value in favor of that of a more deeply nested return.", + core.Decorators.sourcePos(r.pos) + ) bc drop returnType } else { // regarding return value, the protocol is: in place of a `return-stmt`, a sequence of `adapt, store, jump` are inserted. @@ -611,11 +615,10 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder { case Apply(TypeApply(fun, targs), _) => val sym = fun.symbol - val cast = sym match { - case Object_isInstanceOf => false - case Object_asInstanceOf => true - case _ => abort(s"Unexpected type application $fun[sym: ${sym.fullName}] in: $app") - } + val cast = + if (sym == ctx.definitions.Object_isInstanceOf) false + else if (sym == ctx.definitions.Object_asInstanceOf) true + else abort(s"Unexpected type application $fun[sym: ${sym.fullName}] in: $app") val Select(obj, _) = fun val l = tpeTK(obj) @@ -753,7 +756,7 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder { fun match { case Select(qual, _) => val qualSym = findHostClass(qual.tpe, sym) - if (qualSym == ArrayClass) { + if (qualSym == ctx.definitions.ArrayClass) { targetTypeKind = tpeTK(qual) ctx.log(s"Stored target type kind for ${sym.fullName} as $targetTypeKind") } @@ -766,7 +769,7 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder { case _ => } - if ((targetTypeKind != null) && (sym == definitions.Array_clone) && invokeStyle.isDynamic) { + if ((targetTypeKind != null) && (sym == ctx.definitions.Array_clone) && invokeStyle.isDynamic) { val target: String = targetTypeKind.getInternalName bc.invokevirtual(target, "clone", "()Ljava/lang/Object;") } @@ -910,7 +913,7 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder { } /* Generate code that loads args into label parameters. */ - def genLoadLabelArguments(args: List[Tree], lblDef: LabelDef, gotoPos: dotc.util.Positions.Position): Unit = { + def genLoadLabelArguments(args: List[Tree], lblDef: LabelDef, gotoPos: util.Positions.Position): Unit = { val aps = { val params: List[Symbol] = lblDef.params.map(_.symbol) @@ -1024,7 +1027,7 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder { def genCallMethod(method: Symbol, style: InvokeStyle, hostClass0: Symbol = null, - pos: dotc.util.Positions.Position = dotc.util.Positions.NoPosition) { + pos: util.Positions.Position = util.Positions.NoPosition) { val siteSymbol = claszSymbol val hostSymbol = if (hostClass0 == null) method.owner else hostClass0; @@ -1307,7 +1310,7 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder { markProgramPoint(lNonNull) locals.load(eqEqTempLocal) - genCallMethod(Object_equals, icodes.opcodes.Dynamic) + genCallMethod(ctx.definitions.Object_equals, icodes.opcodes.Dynamic) genCZJUMP(success, failure, icodes.NE, BOOL) } } diff --git a/src/dotty/tools/dotc/backend/jvm/BCodeGlue.scala b/src/dotty/tools/dotc/backend/jvm/BCodeGlue.scala index cc6db856fb70..d70a86043e67 100755 --- a/src/dotty/tools/dotc/backend/jvm/BCodeGlue.scala +++ b/src/dotty/tools/dotc/backend/jvm/BCodeGlue.scala @@ -621,7 +621,9 @@ abstract class BCodeGlue { * * must-single-thread */ - def brefType(iname: String): BType = { brefType(dotc.core.Names.typeName(iname.toCharArray(), 0, iname.length())) } + def brefType(iname: String): BType = { + brefType(core.Names.typeName(iname.toCharArray(), 0, iname.length())) + } /* * Creates a BType token for the TypeName received as argument. diff --git a/src/dotty/tools/dotc/backend/jvm/BCodeHelpers.scala b/src/dotty/tools/dotc/backend/jvm/BCodeHelpers.scala index 934cbbd5ae41..f29a44af7db4 100755 --- a/src/dotty/tools/dotc/backend/jvm/BCodeHelpers.scala +++ b/src/dotty/tools/dotc/backend/jvm/BCodeHelpers.scala @@ -142,14 +142,14 @@ abstract class BCodeHelpers extends BCodeTypes with BytecodeWriters { */ object isJavaEntryPoint { - import dotc.core.Types.{MethodType, PolyType} + import core.Types.{MethodType, PolyType} /* * must-single-thread */ - def apply(sym: Symbol, csymCompUnit: CompilationUnit): Boolean = { - def fail(msg: String, pos: dotc.util.Positions.Position = sym.pos) = { - csymCompUnit.warning(sym.pos, + def apply(sym: Symbol, ctx: Context): Boolean = { + def fail(msg: String, pos: util.Positions.Position = sym.pos) = { + ctx.warning(sym.pos, sym.name + s" has a main method with parameter type Array[String], but ${sym.fullName('.')} will not be a runnable program.\n Reason: $msg" // TODO: make this next claim true, if possible @@ -491,7 +491,7 @@ abstract class BCodeHelpers extends BCodeTypes with BytecodeWriters { } def primitiveOrRefType(sym: Symbol): BType = { - assert(sym != definitions.ArrayClass, "Use primitiveOrArrayOrRefType() instead.") + assert(sym != ctx.definitions.ArrayClass, "Use primitiveOrArrayOrRefType() instead.") primitiveTypeMap.getOrElse(sym, newReference(sym)) } @@ -512,25 +512,25 @@ abstract class BCodeHelpers extends BCodeTypes with BytecodeWriters { } } - import dotc.core.Types.{ThisType, ConstantType, TypeRef, ClassInfo} + import core.Types.{ThisType, ConstantType, TypeRef, ClassInfo} // Call to .normalize fixes #3003 (follow type aliases). Otherwise, primitiveOrArrayOrRefType() would return ObjectReference. t match { case ThisType(sym) => - if (sym == ArrayClass) ObjectReference - else phantomTypeMap.getOrElse(sym, exemplar(sym).c) + if (sym == ctx.definitions.ArrayClass) ObjectReference + else phantomTypeMap.getOrElse(sym, exemplar(sym).c) case SingleType(_, sym) => primitiveOrRefType(sym) case _: ConstantType => toTypeKind(t.underlying) case TypeRef(_, sym, args) => - if (sym == ArrayClass) arrayOf(toTypeKind(args.head)) - else primitiveOrRefType2(sym) + if (sym == ctx.definitions.ArrayClass) arrayOf(toTypeKind(args.head)) + else primitiveOrRefType2(sym) case ClassInfo(_, _, sym) => - assert(sym != ArrayClass, "ClassInfoType to ArrayClass!") + assert(sym != ctx.definitions.ArrayClass, "ClassInfoType to ArrayClass!") primitiveOrRefType(sym) case norm => abort( @@ -667,9 +667,10 @@ abstract class BCodeHelpers extends BCodeTypes with BytecodeWriters { (arg: @unchecked) match { case LiteralAnnotArg(const) => + import core.Constants._ if (const.isNonUnitAnyVal) { av.visit(name, const.value) } else { - const.tag match { + (const.tag: @switch) match { case StringTag => assert(const.value != null, const) // TODO this invariant isn't documented in `case class Constant` av.visit(name, const.stringValue) // `stringValue` special-cases null, but that execution path isn't exercised for a const with StringTag diff --git a/src/dotty/tools/dotc/backend/jvm/BCodeIdiomatic.scala b/src/dotty/tools/dotc/backend/jvm/BCodeIdiomatic.scala index 7618c6220901..a7bb9a82b261 100755 --- a/src/dotty/tools/dotc/backend/jvm/BCodeIdiomatic.scala +++ b/src/dotty/tools/dotc/backend/jvm/BCodeIdiomatic.scala @@ -693,6 +693,7 @@ abstract class BCodeIdiomatic extends BCodeGlue { } def abort(msg: => AnyRef)(implicit ctx: Context): Nothing = { + // TODO(lrytz) If this is indeed the right way to abort, this method should probably be added somewhere more centrally (Context?) ctx.error(msg) throw new FatalError(msg) } diff --git a/src/dotty/tools/dotc/backend/jvm/icodes.scala b/src/dotty/tools/dotc/backend/jvm/icodes.scala index 7d63725916c1..67b4f21cc519 100755 --- a/src/dotty/tools/dotc/backend/jvm/icodes.scala +++ b/src/dotty/tools/dotc/backend/jvm/icodes.scala @@ -150,7 +150,7 @@ object icodes { /** Call through super[mix]. * On JVM, translated to `invokespecial`. */ - case class SuperCall(mix: dotc.core.Names.TermName) extends InvokeStyle { + case class SuperCall(mix: core.Names.TermName) extends InvokeStyle { override def isSuper = true override def toString(): String = { "super(" + mix + ")" } } diff --git a/src/dotty/tools/dotc/backend/jvm/scalaPrimitives.scala b/src/dotty/tools/dotc/backend/jvm/scalaPrimitives.scala index 57f26c4f325f..8ddf706cb4a5 100755 --- a/src/dotty/tools/dotc/backend/jvm/scalaPrimitives.scala +++ b/src/dotty/tools/dotc/backend/jvm/scalaPrimitives.scala @@ -223,13 +223,13 @@ object scalaPrimitives { import core.StdNames.nme // scala.Array - val ArrayClass = defn.ArrayClass + lazy val ArrayClass = defn.ArrayClass addPrimitives(ArrayClass, nme.length, LENGTH) addPrimitives(ArrayClass, nme.apply, APPLY) addPrimitives(ArrayClass, nme.update, UPDATE) // scala.Boolean - val BooleanClass = defn.BooleanClass + lazy val BooleanClass = defn.BooleanClass addPrimitives(BooleanClass, nme.EQ, EQ) addPrimitives(BooleanClass, nme.NE, NE) addPrimitives(BooleanClass, nme.UNARY_!, ZNOT) @@ -240,7 +240,7 @@ object scalaPrimitives { addPrimitives(BooleanClass, nme.XOR, XOR) // scala.Byte - val ByteClass = defn.ByteClass + lazy val ByteClass = defn.ByteClass addPrimitives(ByteClass, nme.EQ, EQ) addPrimitives(ByteClass, nme.NE, NE) addPrimitives(ByteClass, nme.ADD, ADD) @@ -273,7 +273,7 @@ object scalaPrimitives { addPrimitives(ByteClass, nme.toDouble, B2D) // scala.Short - val ShortClass = defn.ShortClass + lazy val ShortClass = defn.ShortClass addPrimitives(ShortClass, nme.EQ, EQ) addPrimitives(ShortClass, nme.NE, NE) addPrimitives(ShortClass, nme.ADD, ADD) @@ -306,7 +306,7 @@ object scalaPrimitives { addPrimitives(ShortClass, nme.toDouble, S2D) // scala.Char - val CharClass = defn.CharClass + lazy val CharClass = defn.CharClass addPrimitives(CharClass, nme.EQ, EQ) addPrimitives(CharClass, nme.NE, NE) addPrimitives(CharClass, nme.ADD, ADD) @@ -338,7 +338,7 @@ object scalaPrimitives { addPrimitives(CharClass, nme.toDouble, C2D) // scala.Int - val IntClass = defn.IntClass + lazy val IntClass = defn.IntClass addPrimitives(IntClass, nme.EQ, EQ) addPrimitives(IntClass, nme.NE, NE) addPrimitives(IntClass, nme.ADD, ADD) @@ -370,7 +370,7 @@ object scalaPrimitives { addPrimitives(IntClass, nme.toDouble, I2D) // scala.Long - val LongClass = defn.LongClass + lazy val LongClass = defn.LongClass addPrimitives(LongClass, nme.EQ, EQ) addPrimitives(LongClass, nme.NE, NE) addPrimitives(LongClass, nme.ADD, ADD) @@ -402,7 +402,7 @@ object scalaPrimitives { addPrimitives(LongClass, nme.toDouble, L2D) // scala.Float - val FloatClass = defn.FloatClass + lazy val FloatClass = defn.FloatClass addPrimitives(FloatClass, nme.EQ, EQ) addPrimitives(FloatClass, nme.NE, NE) addPrimitives(FloatClass, nme.ADD, ADD) @@ -427,7 +427,7 @@ object scalaPrimitives { addPrimitives(FloatClass, nme.UNARY_-, NEG) // scala.Double - val DoubleClass = defn.DoubleClass + lazy val DoubleClass = defn.DoubleClass addPrimitives(DoubleClass, nme.EQ, EQ) addPrimitives(DoubleClass, nme.NE, NE) addPrimitives(DoubleClass, nme.ADD, ADD)