diff options
Diffstat (limited to 'src')
52 files changed, 324 insertions, 350 deletions
diff --git a/src/compiler/scala/reflect/reify/phases/Metalevels.scala b/src/compiler/scala/reflect/reify/phases/Metalevels.scala index ea6b5886cc..c69263399f 100644 --- a/src/compiler/scala/reflect/reify/phases/Metalevels.scala +++ b/src/compiler/scala/reflect/reify/phases/Metalevels.scala @@ -33,7 +33,7 @@ trait Metalevels { * * 1) symbol.metalevel < curr_metalevel. In this case reifier will generate a free variable * that captures both the name of the symbol (to be compiled successfully) and its value (to be run successfully). - * For example, x in Example 1 will be reified as follows: Ident(newFreeVar("x", IntClass.tpe, x)) + * For example, x in Example 1 will be reified as follows: Ident(newFreeVar("x", IntTpe, x)) * * 2) symbol.metalevel > curr_metalevel. This leads to a metalevel breach that violates intuitive perception of splicing. * As defined in macro spec, splicing takes a tree and inserts it into another tree - as simple as that. @@ -72,7 +72,7 @@ trait Metalevels { * Since the result of the inner reify is wrapped in a splice, it won't be reified * together with the other parts of the outer reify, but will be inserted into that result verbatim. * - * The inner reify produces an Expr[Int] that wraps Ident(freeVar("x", IntClass.tpe, x)). + * The inner reify produces an Expr[Int] that wraps Ident(freeVar("x", IntTpe, x)). * However the freevar the reification points to will vanish when the compiler processes the outer reify. * That's why we need to replace that freevar with a regular symbol that will point to reified x. * diff --git a/src/compiler/scala/tools/nsc/ast/TreeDSL.scala b/src/compiler/scala/tools/nsc/ast/TreeDSL.scala index 7460d1ab31..b17de9b9d5 100644 --- a/src/compiler/scala/tools/nsc/ast/TreeDSL.scala +++ b/src/compiler/scala/tools/nsc/ast/TreeDSL.scala @@ -74,7 +74,7 @@ trait TreeDSL { if (opSym == NoSymbol) ANY_==(other) else fn(target, opSym, other) } - def ANY_EQ (other: Tree) = OBJ_EQ(other AS ObjectClass.tpe) + def ANY_EQ (other: Tree) = OBJ_EQ(other AS ObjectTpe) def ANY_== (other: Tree) = fn(target, Any_==, other) def ANY_!= (other: Tree) = fn(target, Any_!=, other) def OBJ_!= (other: Tree) = fn(target, Object_!=, other) diff --git a/src/compiler/scala/tools/nsc/backend/ScalaPrimitives.scala b/src/compiler/scala/tools/nsc/backend/ScalaPrimitives.scala index 2007d799df..b8ddb65de9 100644 --- a/src/compiler/scala/tools/nsc/backend/ScalaPrimitives.scala +++ b/src/compiler/scala/tools/nsc/backend/ScalaPrimitives.scala @@ -442,15 +442,17 @@ abstract class ScalaPrimitives { } def addPrimitives(cls: Symbol, method: Name, code: Int) { - val tpe = cls.info - val sym = tpe.member(method) - if (sym == NoSymbol) - inform("Unknown primitive method " + cls + "." + method) - for (s <- sym.alternatives) - addPrimitive( - s, - if (code == ADD && s.info.paramTypes.head == definitions.StringClass.tpe) CONCAT - else code) + val alts = (cls.info member method).alternatives + if (alts.isEmpty) + inform(s"Unknown primitive method $cls.$method") + else alts foreach (s => + addPrimitive(s, + s.info.paramTypes match { + case tp :: _ if code == ADD && tp =:= StringTpe => CONCAT + case _ => code + } + ) + ) } def isCoercion(code: Int): Boolean = (code >= B2B) && (code <= D2D) diff --git a/src/compiler/scala/tools/nsc/backend/icode/GenICode.scala b/src/compiler/scala/tools/nsc/backend/icode/GenICode.scala index cc4d97253f..7263a0d0b9 100644 --- a/src/compiler/scala/tools/nsc/backend/icode/GenICode.scala +++ b/src/compiler/scala/tools/nsc/backend/icode/GenICode.scala @@ -23,12 +23,7 @@ abstract class GenICode extends SubComponent { import global._ import icodes._ import icodes.opcodes._ - import definitions.{ - ArrayClass, ObjectClass, ThrowableClass, StringClass, StringModule, AnyRefClass, - Object_equals, Object_isInstanceOf, Object_asInstanceOf, ScalaRunTimeModule, - BoxedNumberClass, BoxedCharacterClass, - getMember - } + import definitions._ import scalaPrimitives.{ isArrayOp, isComparisonOp, isLogicalOp, isUniversalEqualityOp, isReferenceEqualityOp @@ -182,7 +177,7 @@ abstract class GenICode extends SubComponent { } private def genThrow(expr: Tree, ctx: Context): (Context, TypeKind) = { - require(expr.tpe <:< ThrowableClass.tpe, expr.tpe) + require(expr.tpe <:< ThrowableTpe, expr.tpe) val thrownKind = toTypeKind(expr.tpe) val ctx1 = genLoad(expr, ctx, thrownKind) @@ -302,7 +297,7 @@ abstract class GenICode extends SubComponent { } private def genSynchronized(tree: Apply, ctx: Context, expectedType: TypeKind): (Context, TypeKind) = { val Apply(fun, args) = tree - val monitor = ctx.makeLocal(tree.pos, ObjectClass.tpe, "monitor") + val monitor = ctx.makeLocal(tree.pos, ObjectTpe, "monitor") var monitorResult: Local = null val argTpe = args.head.tpe val hasResult = expectedType != UNIT @@ -1468,7 +1463,7 @@ abstract class GenICode extends SubComponent { */ def genEqEqPrimitive(l: Tree, r: Tree, ctx: Context)(thenCtx: Context, elseCtx: Context): Boolean = { def getTempLocal = ctx.method.lookupLocal(nme.EQEQ_LOCAL_VAR) getOrElse { - ctx.makeLocal(l.pos, AnyRefClass.tpe, nme.EQEQ_LOCAL_VAR.toString) + ctx.makeLocal(l.pos, AnyRefTpe, nme.EQEQ_LOCAL_VAR.toString) } /* True if the equality comparison is between values that require the use of the rich equality @@ -2039,7 +2034,7 @@ abstract class GenICode extends SubComponent { this.addActiveHandler(exh) // .. and body aswell val exhStartCtx = finalizerCtx.enterExceptionHandler(exh) exhStartCtx.bb killIf outerCtx.bb.ignore - val exception = exhStartCtx.makeLocal(finalizer.pos, ThrowableClass.tpe, "exc") + val exception = exhStartCtx.makeLocal(finalizer.pos, ThrowableTpe, "exc") loadException(exhStartCtx, exh, finalizer.pos) exhStartCtx.bb.emit(STORE_LOCAL(exception)) val exhEndCtx = genLoad(finalizer, exhStartCtx, UNIT) diff --git a/src/compiler/scala/tools/nsc/backend/icode/analysis/CopyPropagation.scala b/src/compiler/scala/tools/nsc/backend/icode/analysis/CopyPropagation.scala index 192890a509..0c3f92f13f 100644 --- a/src/compiler/scala/tools/nsc/backend/icode/analysis/CopyPropagation.scala +++ b/src/compiler/scala/tools/nsc/backend/icode/analysis/CopyPropagation.scala @@ -457,7 +457,7 @@ abstract class CopyPropagation { final def simulateCall(state: copyLattice.State, method: Symbol, static: Boolean): copyLattice.State = { val out = new copyLattice.State(state.bindings, state.stack) out.stack = out.stack.drop(method.info.paramTypes.length + (if (static) 0 else 1)) - if (method.info.resultType != definitions.UnitClass.tpe && !method.isConstructor) + if (method.info.resultType != definitions.UnitTpe && !method.isConstructor) out.stack = Unknown :: out.stack if (!isPureMethod(method)) invalidateRecords(out) diff --git a/src/compiler/scala/tools/nsc/javac/JavaParsers.scala b/src/compiler/scala/tools/nsc/javac/JavaParsers.scala index 1eecca28c5..2a799acbc7 100644 --- a/src/compiler/scala/tools/nsc/javac/JavaParsers.scala +++ b/src/compiler/scala/tools/nsc/javac/JavaParsers.scala @@ -251,15 +251,15 @@ trait JavaParsers extends ast.parser.ParsersCommon with JavaScanners { def basicType(): Tree = atPos(in.pos) { in.token match { - case BYTE => in.nextToken(); TypeTree(ByteClass.tpe) - case SHORT => in.nextToken(); TypeTree(ShortClass.tpe) - case CHAR => in.nextToken(); TypeTree(CharClass.tpe) - case INT => in.nextToken(); TypeTree(IntClass.tpe) - case LONG => in.nextToken(); TypeTree(LongClass.tpe) - case FLOAT => in.nextToken(); TypeTree(FloatClass.tpe) - case DOUBLE => in.nextToken(); TypeTree(DoubleClass.tpe) - case BOOLEAN => in.nextToken(); TypeTree(BooleanClass.tpe) - case _ => syntaxError("illegal start of type", skipIt = true); errorTypeTree + case BYTE => in.nextToken(); TypeTree(ByteTpe) + case SHORT => in.nextToken(); TypeTree(ShortTpe) + case CHAR => in.nextToken(); TypeTree(CharTpe) + case INT => in.nextToken(); TypeTree(IntTpe) + case LONG => in.nextToken(); TypeTree(LongTpe) + case FLOAT => in.nextToken(); TypeTree(FloatTpe) + case DOUBLE => in.nextToken(); TypeTree(DoubleTpe) + case BOOLEAN => in.nextToken(); TypeTree(BooleanTpe) + case _ => syntaxError("illegal start of type", skipIt = true); errorTypeTree } } @@ -462,7 +462,7 @@ trait JavaParsers extends ast.parser.ParsersCommon with JavaScanners { var rtpt = if (isVoid) { in.nextToken() - TypeTree(UnitClass.tpe) setPos in.pos + TypeTree(UnitTpe) setPos in.pos } else typ() var pos = in.currentPos val rtptName = rtpt match { @@ -785,7 +785,7 @@ trait JavaParsers extends ast.parser.ParsersCommon with JavaScanners { blankExpr), DefDef( Modifiers(Flags.JAVA | Flags.STATIC), nme.valueOf, List(), - List(List(makeParam("x", TypeTree(StringClass.tpe)))), + List(List(makeParam("x", TypeTree(StringTpe)))), enumType, blankExpr)) accept(RBRACE) diff --git a/src/compiler/scala/tools/nsc/symtab/classfile/ClassfileParser.scala b/src/compiler/scala/tools/nsc/symtab/classfile/ClassfileParser.scala index 9afa1ba10d..69111f9b0c 100644 --- a/src/compiler/scala/tools/nsc/symtab/classfile/ClassfileParser.scala +++ b/src/compiler/scala/tools/nsc/symtab/classfile/ClassfileParser.scala @@ -478,7 +478,7 @@ abstract class ClassfileParser { u2 // skip superclass val ifaces = u2 in.bp += ifaces * 2 // .. and iface count interfaces - List(AnyRefClass.tpe) // dummy superclass, will be replaced by pickled information + List(AnyRefTpe) // dummy superclass, will be replaced by pickled information } else raiseLoaderLevel { val superType = if (jflags.isAnnotation) { u2; AnnotationClass.tpe } @@ -657,15 +657,15 @@ abstract class ClassfileParser { def sig2type(tparams: immutable.Map[Name,Symbol], skiptvs: Boolean): Type = { val tag = sig.charAt(index); index += 1 tag match { - case BYTE_TAG => ByteClass.tpe - case CHAR_TAG => CharClass.tpe - case DOUBLE_TAG => DoubleClass.tpe - case FLOAT_TAG => FloatClass.tpe - case INT_TAG => IntClass.tpe - case LONG_TAG => LongClass.tpe - case SHORT_TAG => ShortClass.tpe - case VOID_TAG => UnitClass.tpe - case BOOL_TAG => BooleanClass.tpe + case BYTE_TAG => ByteTpe + case CHAR_TAG => CharTpe + case DOUBLE_TAG => DoubleTpe + case FLOAT_TAG => FloatTpe + case INT_TAG => IntTpe + case LONG_TAG => LongTpe + case SHORT_TAG => ShortTpe + case VOID_TAG => UnitTpe + case BOOL_TAG => BooleanTpe case 'L' => def processInner(tp: Type): Type = tp match { case TypeRef(pre, sym, args) if (!sym.isStatic) => @@ -739,8 +739,8 @@ abstract class ClassfileParser { // NOTE that the comparison to Object only works for abstract types bounded by classes that are strict subclasses of Object // if the bound is exactly Object, it will have been converted to Any, and the comparison will fail // see also RestrictJavaArraysMap (when compiling java sources directly) - if (elemtp.typeSymbol.isAbstractType && !(elemtp <:< ObjectClass.tpe)) { - elemtp = intersectionType(List(elemtp, ObjectClass.tpe)) + if (elemtp.typeSymbol.isAbstractType && !(elemtp <:< ObjectTpe)) { + elemtp = intersectionType(List(elemtp, ObjectTpe)) } arrayType(elemtp) @@ -761,7 +761,7 @@ abstract class ClassfileParser { case 'T' => val n = subName(';'.==).toTypeName index += 1 - if (skiptvs) AnyClass.tpe + if (skiptvs) AnyTpe else tparams(n).typeConstructor } } // sig2type(tparams, skiptvs) diff --git a/src/compiler/scala/tools/nsc/transform/AddInterfaces.scala b/src/compiler/scala/tools/nsc/transform/AddInterfaces.scala index ba75f40a3a..0dcf4d00b7 100644 --- a/src/compiler/scala/tools/nsc/transform/AddInterfaces.scala +++ b/src/compiler/scala/tools/nsc/transform/AddInterfaces.scala @@ -143,7 +143,7 @@ abstract class AddInterfaces extends InfoTransform { self: Erasure => decls enter ( implClass.newMethod(nme.MIXIN_CONSTRUCTOR, implClass.pos) - setInfo MethodType(Nil, UnitClass.tpe) + setInfo MethodType(Nil, UnitTpe) ) } @@ -189,7 +189,7 @@ abstract class AddInterfaces extends InfoTransform { self: Erasure => case ClassInfoType(parents, decls, _) => assert(phase == implClassPhase, tp) // Impl class parents: Object first, matching interface last. - val implParents = ObjectClass.tpe +: (parents.tail map mixinToImplClass filter (_.typeSymbol != ObjectClass)) :+ iface.tpe + val implParents = ObjectTpe +: (parents.tail map mixinToImplClass filter (_.typeSymbol != ObjectClass)) :+ iface.tpe ClassInfoType(implParents, implDecls(implSym, decls), implSym) case PolyType(_, restpe) => implType(restpe) @@ -209,7 +209,7 @@ abstract class AddInterfaces extends InfoTransform { self: Erasure => case Nil => Nil case hd :: tl => assert(!hd.typeSymbol.isTrait, clazz) - if (clazz.isTrait) erasedTypeRef(ObjectClass) :: tl + if (clazz.isTrait) ObjectTpe :: tl else parents } val decls1 = scopeTransform(clazz)( diff --git a/src/compiler/scala/tools/nsc/transform/CleanUp.scala b/src/compiler/scala/tools/nsc/transform/CleanUp.scala index d159408f55..fad16c9956 100644 --- a/src/compiler/scala/tools/nsc/transform/CleanUp.scala +++ b/src/compiler/scala/tools/nsc/transform/CleanUp.scala @@ -169,11 +169,11 @@ abstract class CleanUp extends Transform with ast.TreeDSL { def testForName(name: Name): Tree => Tree = t => ( if (nme.CommonOpNames(name)) - gen.mkMethodCall(definitions.Boxes_isNumberOrBool, t :: Nil) + gen.mkMethodCall(Boxes_isNumberOrBool, t :: Nil) else if (nme.BooleanOpNames(name)) t IS_OBJ BoxedBooleanClass.tpe else - gen.mkMethodCall(definitions.Boxes_isNumber, t :: Nil) + gen.mkMethodCall(Boxes_isNumber, t :: Nil) ) /* The Tree => Tree function in the return is necessary to prevent the original qual @@ -188,7 +188,7 @@ abstract class CleanUp extends Transform with ast.TreeDSL { else if (params.tail.isEmpty) nme.primitiveInfixMethodName(name) else nme.NO_NAME ) - definitions.getDeclIfDefined(BoxesRunTimeClass, methodName) match { + getDeclIfDefined(BoxesRunTimeClass, methodName) match { case NoSymbol => None case sym => assert(!sym.isOverloaded, sym) ; Some((sym, testForName(name))) } @@ -226,11 +226,11 @@ abstract class CleanUp extends Transform with ast.TreeDSL { // If there's any chance this signature could be met by an Array. val isArrayMethodSignature = { def typesMatchApply = paramTypes match { - case List(tp) => tp <:< IntClass.tpe + case List(tp) => tp <:< IntTpe case _ => false } def typesMatchUpdate = paramTypes match { - case List(tp1, tp2) => (tp1 <:< IntClass.tpe) && isMaybeUnit + case List(tp1, tp2) => (tp1 <:< IntTpe) && isMaybeUnit case _ => false } @@ -267,7 +267,7 @@ abstract class CleanUp extends Transform with ast.TreeDSL { val invokeName = MethodClass.tpe member nme.invoke_ // scala.reflect.Method.invoke(...) def cache = REF(reflectiveMethodCache(ad.symbol.name.toString, paramTypes)) // cache Symbol def lookup = Apply(cache, List(qual1() GETCLASS())) // get Method object from cache - def invokeArgs = ArrayValue(TypeTree(ObjectClass.tpe), params) // args for invocation + def invokeArgs = ArrayValue(TypeTree(ObjectTpe), params) // args for invocation def invocation = (lookup DOT invokeName)(qual1(), invokeArgs) // .invoke(qual1, ...) // exception catching machinery diff --git a/src/compiler/scala/tools/nsc/transform/Constructors.scala b/src/compiler/scala/tools/nsc/transform/Constructors.scala index 5079108c27..385bf2dade 100644 --- a/src/compiler/scala/tools/nsc/transform/Constructors.scala +++ b/src/compiler/scala/tools/nsc/transform/Constructors.scala @@ -165,7 +165,7 @@ abstract class Constructors extends Transform with ast.TreeDSL { from.tpe.typeSymbol.isPrimitiveValueClass) result else localTyper.typedPos(to.pos) { // `throw null` has the same effect as `throw new NullPointerException`, see JVM spec on instruction `athrow` - IF (from OBJ_EQ NULL) THEN Throw(gen.mkZero(ThrowableClass.tpe)) ELSE result + IF (from OBJ_EQ NULL) THEN Throw(gen.mkZero(ThrowableTpe)) ELSE result } } @@ -469,10 +469,10 @@ abstract class Constructors extends Transform with ast.TreeDSL { val methodName = currentUnit.freshTermName("delayedEndpoint$" + clazz.fullNameAsName('$').toString + "$") val methodSym = clazz.newMethod(methodName, impl.pos, SYNTHETIC | FINAL) - methodSym setInfoAndEnter MethodType(Nil, UnitClass.tpe) + methodSym setInfoAndEnter MethodType(Nil, UnitTpe) // changeOwner needed because the `stats` contained in the DefDef were owned by the template, not long ago. - val blk = Block(stats, gen.mkZero(UnitClass.tpe)).changeOwner(impl.symbol -> methodSym) + val blk = Block(stats, gen.mkZero(UnitTpe)).changeOwner(impl.symbol -> methodSym) val delayedDD = localTyper typed { DefDef(methodSym, Nil, blk) } delayedDD.asInstanceOf[DefDef] @@ -495,7 +495,7 @@ abstract class Constructors extends Transform with ast.TreeDSL { val applyMethod: MethodSymbol = ( closureClass newMethod(nme.apply, impl.pos, FINAL) - setInfoAndEnter MethodType(Nil, ObjectClass.tpe) + setInfoAndEnter MethodType(Nil, ObjectTpe) ) val outerFieldDef = ValDef(outerField) val closureClassTyper = localTyper.atOwner(closureClass) diff --git a/src/compiler/scala/tools/nsc/transform/Erasure.scala b/src/compiler/scala/tools/nsc/transform/Erasure.scala index ac79c60254..423def3704 100644 --- a/src/compiler/scala/tools/nsc/transform/Erasure.scala +++ b/src/compiler/scala/tools/nsc/transform/Erasure.scala @@ -111,7 +111,7 @@ abstract class Erasure extends AddInterfaces if (tpe1 eq tpe) t else ExistentialType(tparams, tpe1) case t => - if (boxedClass contains t.typeSymbol) ObjectClass.tpe + if (boxedClass contains t.typeSymbol) ObjectTpe else tp } def apply(tp: Type): Type = tp.dealiasWiden match { @@ -123,16 +123,16 @@ abstract class Erasure extends AddInterfaces case tp1 @ TypeRef(pre, sym, args) => def argApply(tp: Type) = { val tp1 = apply(tp) - if (tp1.typeSymbol == UnitClass) ObjectClass.tpe + if (tp1.typeSymbol == UnitClass) ObjectTpe else squashBoxed(tp1) } if (sym == ArrayClass && args.nonEmpty) - if (unboundedGenericArrayLevel(tp1) == 1) ObjectClass.tpe + if (unboundedGenericArrayLevel(tp1) == 1) ObjectTpe else mapOver(tp1) else if (sym == AnyClass || sym == AnyValClass || sym == SingletonClass) - ObjectClass.tpe + ObjectTpe else if (sym == UnitClass) - BoxedUnitClass.tpe + BoxedUnitTpe else if (sym == NothingClass) RuntimeNothingClass.tpe else if (sym == NullClass) @@ -145,7 +145,7 @@ abstract class Erasure extends AddInterfaces } case tp1 @ MethodType(params, restpe) => val params1 = mapOver(params) - val restpe1 = if (restpe.typeSymbol == UnitClass) UnitClass.tpe else apply(restpe) + val restpe1 = if (restpe.typeSymbol == UnitClass) UnitTpe else apply(restpe) if ((params1 eq params) && (restpe1 eq restpe)) tp1 else MethodType(params1, restpe1) case tp1 @ RefinedType(parents, decls) => @@ -182,7 +182,7 @@ abstract class Erasure extends AddInterfaces // java is unthrilled about seeing interfaces inherit from classes val ok = parents filter (p => p.typeSymbol.isTrait || p.typeSymbol.isInterface) // traits should always list Object. - if (ok.isEmpty || ok.head.typeSymbol != ObjectClass) ObjectClass.tpe :: ok + if (ok.isEmpty || ok.head.typeSymbol != ObjectClass) ObjectTpe :: ok else ok } else parents @@ -193,7 +193,7 @@ abstract class Erasure extends AddInterfaces def boundsSig(bounds: List[Type]) = { val (isTrait, isClass) = bounds partition (_.typeSymbol.isTrait) val classPart = isClass match { - case Nil => ":" // + boxedSig(ObjectClass.tpe) + case Nil => ":" // + boxedSig(ObjectTpe) case x :: _ => ":" + boxedSig(x) } classPart :: (isTrait map boxedSig) mkString ":" @@ -220,8 +220,8 @@ abstract class Erasure extends AddInterfaces def argSig(tp: Type) = if (existentiallyBound contains tp.typeSymbol) { val bounds = tp.typeSymbol.info.bounds - if (!(AnyRefClass.tpe <:< bounds.hi)) "+" + boxedSig(bounds.hi) - else if (!(bounds.lo <:< NullClass.tpe)) "-" + boxedSig(bounds.lo) + if (!(AnyRefTpe <:< bounds.hi)) "+" + boxedSig(bounds.hi) + else if (!(bounds.lo <:< NullTpe)) "-" + boxedSig(bounds.lo) else "*" } else { boxedSig(tp) @@ -247,7 +247,7 @@ abstract class Erasure extends AddInterfaces // If args isEmpty, Array is being used as a type constructor if (sym == ArrayClass && args.nonEmpty) { - if (unboundedGenericArrayLevel(tp) == 1) jsig(ObjectClass.tpe) + if (unboundedGenericArrayLevel(tp) == 1) jsig(ObjectTpe) else ARRAY_TAG.toString+(args map (jsig(_))).mkString } else if (isTypeParameterInSig(sym, sym0)) { @@ -255,16 +255,16 @@ abstract class Erasure extends AddInterfaces "" + TVAR_TAG + sym.name + ";" } else if (sym == AnyClass || sym == AnyValClass || sym == SingletonClass) - jsig(ObjectClass.tpe) + jsig(ObjectTpe) else if (sym == UnitClass) - jsig(BoxedUnitClass.tpe) + jsig(BoxedUnitTpe) else if (sym == NothingClass) jsig(RuntimeNothingClass.tpe) else if (sym == NullClass) jsig(RuntimeNullClass.tpe) else if (isPrimitiveValueClass(sym)) { - if (!primitiveOK) jsig(ObjectClass.tpe) - else if (sym == UnitClass) jsig(BoxedUnitClass.tpe) + if (!primitiveOK) jsig(ObjectTpe) + else if (sym == UnitClass) jsig(BoxedUnitTpe) else abbrvTag(sym).toString } else if (sym.isDerivedValueClass) { @@ -568,7 +568,7 @@ abstract class Erasure extends AddInterfaces log(s"boxing an unbox: ${tree.symbol} -> ${arg.tpe}") arg case _ => - (REF(boxMethod(x)) APPLY tree) setPos (tree.pos) setType ObjectClass.tpe + (REF(boxMethod(x)) APPLY tree) setPos (tree.pos) setType ObjectTpe } } } @@ -688,7 +688,7 @@ abstract class Erasure extends AddInterfaces tree match { case Apply(TypeApply(sel @ Select(qual, name), List(targ)), List()) if tree.symbol == Any_asInstanceOf => - val qual1 = typedQualifier(qual, NOmode, ObjectClass.tpe) // need to have an expected type, see #3037 + val qual1 = typedQualifier(qual, NOmode, ObjectTpe) // need to have an expected type, see #3037 if (isPrimitiveValueType(targ.tpe) || isErasedValueType(targ.tpe)) { val noNullCheckNeeded = targ.tpe match { @@ -704,7 +704,7 @@ abstract class Erasure extends AddInterfaces val untyped = // util.trace("new asinstanceof test") { gen.evalOnce(qual1, context.owner, context.unit) { qual => - If(Apply(Select(qual(), nme.eq), List(Literal(Constant(null)) setType NullClass.tpe)), + If(Apply(Select(qual(), nme.eq), List(Literal(Constant(null)) setType NullTpe)), Literal(Constant(null)) setType targ.tpe, unbox(qual(), targ.tpe)) } @@ -991,7 +991,7 @@ abstract class Erasure extends AddInterfaces def preEraseIsInstanceOf = { fn match { case TypeApply(sel @ Select(qual, name), List(targ)) => - if (qual.tpe != null && isPrimitiveValueClass(qual.tpe.typeSymbol) && targ.tpe != null && targ.tpe <:< AnyRefClass.tpe) + if (qual.tpe != null && isPrimitiveValueClass(qual.tpe.typeSymbol) && targ.tpe != null && targ.tpe <:< AnyRefTpe) unit.error(sel.pos, "isInstanceOf cannot test if value types are references.") def mkIsInstanceOf(q: () => Tree)(tp: Type): Tree = @@ -1002,7 +1002,7 @@ abstract class Erasure extends AddInterfaces List()) setPos tree.pos targ.tpe match { case SingleType(_, _) | ThisType(_) | SuperType(_, _) => - val cmpOp = if (targ.tpe <:< AnyValClass.tpe) Any_equals else Object_eq + val cmpOp = if (targ.tpe <:< AnyValTpe) Any_equals else Object_eq atPos(tree.pos) { Apply(Select(qual, cmpOp), List(gen.mkAttributedQualifier(targ.tpe))) } diff --git a/src/compiler/scala/tools/nsc/transform/LazyVals.scala b/src/compiler/scala/tools/nsc/transform/LazyVals.scala index 69a93b482c..15ca916ac1 100644 --- a/src/compiler/scala/tools/nsc/transform/LazyVals.scala +++ b/src/compiler/scala/tools/nsc/transform/LazyVals.scala @@ -277,7 +277,7 @@ abstract class LazyVals extends Transform with TypingTransformers with ast.TreeD if (bmps.length > n) bmps(n) else { - val sym = meth.newVariable(nme.newBitmapName(nme.BITMAP_NORMAL, n), meth.pos).setInfo(ByteClass.tpe) + val sym = meth.newVariable(nme.newBitmapName(nme.BITMAP_NORMAL, n), meth.pos).setInfo(ByteTpe) enteringTyper { sym addAnnotation VolatileAttr } diff --git a/src/compiler/scala/tools/nsc/transform/Mixin.scala b/src/compiler/scala/tools/nsc/transform/Mixin.scala index 7fe7947239..eca958fd8d 100644 --- a/src/compiler/scala/tools/nsc/transform/Mixin.scala +++ b/src/compiler/scala/tools/nsc/transform/Mixin.scala @@ -213,7 +213,7 @@ abstract class Mixin extends InfoTransform with ast.TreeDSL { val newFlags = field.flags & ~PrivateLocal | ACCESSOR | lateDEFERRED val setter = clazz.newMethod(setterName, field.pos, newFlags) // TODO preserve pre-erasure info? - setter setInfo MethodType(setter.newSyntheticValueParams(List(field.info)), UnitClass.tpe) + setter setInfo MethodType(setter.newSyntheticValueParams(List(field.info)), UnitTpe) if (field.needsExpandedSetterName) setter.name = nme.expandedSetterName(setter.name, clazz) diff --git a/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala b/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala index 90ca157090..6fbeb47cd4 100644 --- a/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala +++ b/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala @@ -52,7 +52,9 @@ import scala.annotation.tailrec */ abstract class SpecializeTypes extends InfoTransform with TypingTransformers { import global._ + import definitions._ import Flags._ + /** the name of the phase: */ val phaseName: String = "specialize" @@ -68,13 +70,6 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers { private implicit val typeOrdering: Ordering[Type] = Ordering[String] on ("" + _.typeSymbol.name) - import definitions.{ - BooleanClass, UnitClass, ArrayClass, - ScalaValueClasses, isPrimitiveValueClass, isPrimitiveValueType, - SpecializedClass, UnspecializedClass, AnyRefClass, ObjectClass, - GroupOfSpecializable, uncheckedVarianceClass, ScalaInlineClass - } - import rootMirror.RootClass /** TODO - this is a lot of maps. */ @@ -136,14 +131,14 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers { } } - // If we replace `isBoundedGeneric` with (tp <:< AnyRefClass.tpe), + // If we replace `isBoundedGeneric` with (tp <:< AnyRefTpe), // then pos/spec-List.scala fails - why? Does this kind of check fail // for similar reasons? Does `sym.isAbstractType` make a difference? private def isSpecializedAnyRefSubtype(tp: Type, sym: Symbol) = { specializedOn(sym).exists(s => !isPrimitiveValueClass(s)) && !isPrimitiveValueClass(tp.typeSymbol) && isBoundedGeneric(tp) - //(tp <:< AnyRefClass.tpe) + //(tp <:< AnyRefTpe) } object TypeEnv { @@ -164,7 +159,7 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers { def includes(t1: TypeEnv, t2: TypeEnv) = t1 forall { case (sym, tpe) => t2 get sym exists { t2tp => - (tpe == t2tp) || !(isPrimitiveValueType(tpe) || isPrimitiveValueType(t2tp)) // u.t.b. (t2tp <:< AnyRefClass.tpe) + (tpe == t2tp) || !(isPrimitiveValueType(tpe) || isPrimitiveValueType(t2tp)) // u.t.b. (t2tp <:< AnyRefTpe) } } @@ -180,7 +175,7 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers { env forall { case (tvar, tpe) => tvar.isSpecialized && (concreteTypes(tvar) contains tpe) && { (sym.typeParams contains tvar) || - (sym.owner != RootClass && (sym.owner.typeParams contains tvar)) + (sym.owner != rootMirror.RootClass && (sym.owner.typeParams contains tvar)) } } } @@ -294,7 +289,7 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers { // when searching for a specialized class, take care to map all // type parameters that are subtypes of AnyRef to AnyRef val args1 = map2(args, sym.info.typeParams)((tp, orig) => - if (isSpecializedAnyRefSubtype(tp, orig)) AnyRefClass.tpe + if (isSpecializedAnyRefSubtype(tp, orig)) AnyRefTpe else tp ) specializedClass.get((sym, TypeEnv.fromSpecialization(sym, args1))) match { @@ -333,8 +328,8 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers { else { val (base, cs, ms) = nme.splitSpecializedName(name) newTermName(base.toString + "$" - + "m" + ms + types1.map(t => definitions.abbrvTag(t.typeSymbol)).mkString("", "", "") - + "c" + cs + types2.map(t => definitions.abbrvTag(t.typeSymbol)).mkString("", "", "$sp")) + + "m" + ms + types1.map(t => abbrvTag(t.typeSymbol)).mkString("", "", "") + + "c" + cs + types2.map(t => abbrvTag(t.typeSymbol)).mkString("", "", "$sp")) } ) @@ -360,7 +355,7 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers { specializedOn(sym) map (s => specializesClass(s).tpe) sorted if (isBoundedGeneric(sym.tpe) && (types contains AnyRefClass)) - reporter.warning(sym.pos, sym + " is always a subtype of " + AnyRefClass.tpe + ".") + reporter.warning(sym.pos, sym + " is always a subtype of " + AnyRefTpe + ".") types } @@ -380,7 +375,7 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers { // zip the keys with each permutation to create a TypeEnv. // If we don't exclude the "all AnyRef" specialization, we will // incur duplicate members and crash during mixin. - loop(keys map concreteTypes) filterNot (_ forall (_ <:< AnyRefClass.tpe)) map (xss => Map(keys zip xss: _*)) + loop(keys map concreteTypes) filterNot (_ forall (_ <:< AnyRefTpe)) map (xss => Map(keys zip xss: _*)) } /** Does the given 'sym' need to be specialized in the environment 'env'? @@ -412,7 +407,7 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers { loop(immutable.Set.empty, tpes) } def specializedTypeVars(sym: Symbol): immutable.Set[Symbol] = ( - if (definitions.neverHasTypeParameters(sym)) immutable.Set.empty + if (neverHasTypeParameters(sym)) immutable.Set.empty else enteringTyper(specializedTypeVars(sym.info)) ) @@ -454,7 +449,7 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers { sClassMap.getOrElseUpdate(tparam, tparam.cloneSymbol(sClass, tparam.flags, tparam.name append tpnme.SPECIALIZED_SUFFIX) - modifyInfo (info => TypeBounds(info.bounds.lo, AnyRefClass.tpe)) + modifyInfo (info => TypeBounds(info.bounds.lo, AnyRefTpe)) ).tpe } @@ -488,7 +483,7 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers { foreach2(syms, cloned) { (orig, cln) => cln.removeAnnotation(SpecializedClass) if (env.contains(orig)) - cln modifyInfo (info => TypeBounds(info.bounds.lo, AnyRefClass.tpe)) + cln modifyInfo (info => TypeBounds(info.bounds.lo, AnyRefTpe)) } cloned map (_ substInfo (syms, cloned)) } @@ -497,7 +492,7 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers { * the specialized symbol (class (specialization) or member (normalization)), leaves everything else as-is. */ private def mapAnyRefsInSpecSym(env: TypeEnv, origsym: Symbol, specsym: Symbol): TypeEnv = env map { - case (sym, tp) if tp == AnyRefClass.tpe && sym.owner == origsym => (sym, typeParamSubAnyRef(sym, specsym)) + case (sym, tp) if tp == AnyRefTpe && sym.owner == origsym => (sym, typeParamSubAnyRef(sym, specsym)) case x => x } @@ -505,7 +500,7 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers { * the original class, leaves everything else as-is. */ private def mapAnyRefsInOrigCls(env: TypeEnv, origcls: Symbol): TypeEnv = env map { - case (sym, tp) if (tp == AnyRefClass.tpe) && sym.owner == origcls => (sym, sym.tpe) + case (sym, tp) if (tp == AnyRefTpe) && sym.owner == origcls => (sym, sym.tpe) case x => x } @@ -733,7 +728,7 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers { val specSetter = mkAccessor(specVal, specGetter.setterName) .resetFlag(STABLE) specSetter.setInfo(MethodType(specSetter.newSyntheticValueParams(List(specVal.info)), - UnitClass.tpe)) + UnitTpe)) val origSetter = overrideIn(sClass, m.setter(clazz)) info(origSetter) = Forward(specSetter) enterMember(specSetter) @@ -1150,7 +1145,7 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers { ) private def unspecializableClass(tp: Type) = ( - definitions.isRepeatedParamType(tp) // ??? + isRepeatedParamType(tp) // ??? || tp.typeSymbol.isJavaDefined || tp.typeSymbol.isPackageClass ) @@ -1744,10 +1739,10 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers { } if (hasSpecializedFields) { val isSpecializedInstance = sClass :: sClass.parentSymbols exists (_ hasFlag SPECIALIZED) - val sym = sClass.newMethod(nme.SPECIALIZED_INSTANCE, sClass.pos) setInfoAndEnter MethodType(Nil, BooleanClass.tpe) + val sym = sClass.newMethod(nme.SPECIALIZED_INSTANCE, sClass.pos) setInfoAndEnter MethodType(Nil, BooleanTpe) mbrs += atPos(sym.pos) { - DefDef(sym, Literal(Constant(isSpecializedInstance)).setType(BooleanClass.tpe)).setType(NoType) + DefDef(sym, Literal(Constant(isSpecializedInstance)).setType(BooleanTpe)).setType(NoType) } } mbrs.toList diff --git a/src/compiler/scala/tools/nsc/transform/UnCurry.scala b/src/compiler/scala/tools/nsc/transform/UnCurry.scala index d7be0ed180..64f4e579e1 100644 --- a/src/compiler/scala/tools/nsc/transform/UnCurry.scala +++ b/src/compiler/scala/tools/nsc/transform/UnCurry.scala @@ -142,7 +142,7 @@ abstract class UnCurry extends InfoTransform /** Return non-local return key for given method */ private def nonLocalReturnKey(meth: Symbol) = nonLocalReturnKeys.getOrElseUpdate(meth, - meth.newValue(unit.freshTermName("nonLocalReturnKey"), meth.pos, SYNTHETIC) setInfo ObjectClass.tpe + meth.newValue(unit.freshTermName("nonLocalReturnKey"), meth.pos, SYNTHETIC) setInfo ObjectTpe ) /** Generate a non-local return throw with given return expression from given method. @@ -184,7 +184,7 @@ abstract class UnCurry extends InfoTransform THEN ((ex DOT nme.value)()) ELSE (Throw(Ident(ex))) ) - val keyDef = ValDef(key, New(ObjectClass.tpe)) + val keyDef = ValDef(key, New(ObjectTpe)) val tryCatch = Try(body, pat -> rhs) for (Try(t, catches, _) <- body ; cdef <- catches ; if treeInfo catchesThrowable cdef) @@ -291,7 +291,7 @@ abstract class UnCurry extends InfoTransform def getClassTag(tp: Type): Tree = { val tag = localTyper.resolveClassTag(tree.pos, tp) // Don't want bottom types getting any further than this (SI-4024) - if (tp.typeSymbol.isBottomClass) getClassTag(AnyClass.tpe) + if (tp.typeSymbol.isBottomClass) getClassTag(AnyTpe) else if (!tag.isEmpty) tag else if (tp.bounds.hi ne tp) getClassTag(tp.bounds.hi) else localTyper.TyperErrorGen.MissingClassTagError(tree, tp) @@ -547,7 +547,7 @@ abstract class UnCurry extends InfoTransform def isThrowable(pat: Tree): Boolean = pat match { case Typed(Ident(nme.WILDCARD), tpt) => - tpt.tpe =:= ThrowableClass.tpe + tpt.tpe =:= ThrowableTpe case Bind(_, pat) => isThrowable(pat) case _ => @@ -735,7 +735,7 @@ abstract class UnCurry extends InfoTransform // becomes def foo[T](a: Int, b: Array[Object]) // instead of def foo[T](a: Int, b: Array[T]) ===> def foo[T](a: Int, b: Object) arrayType( - if (arg.typeSymbol.isTypeParameterOrSkolem) ObjectClass.tpe + if (arg.typeSymbol.isTypeParameterOrSkolem) ObjectTpe else arg ) } diff --git a/src/compiler/scala/tools/nsc/transform/patmat/MatchAnalysis.scala b/src/compiler/scala/tools/nsc/transform/patmat/MatchAnalysis.scala index 68883831a2..f527c30b8a 100644 --- a/src/compiler/scala/tools/nsc/transform/patmat/MatchAnalysis.scala +++ b/src/compiler/scala/tools/nsc/transform/patmat/MatchAnalysis.scala @@ -19,7 +19,7 @@ trait TreeAndTypeAnalysis extends Debugging { // we use subtyping as a model for implication between instanceof tests // i.e., when S <:< T we assume x.isInstanceOf[S] implies x.isInstanceOf[T] // unfortunately this is not true in general: - // SI-6022 expects instanceOfTpImplies(ProductClass.tpe, AnyRefClass.tpe) + // SI-6022 expects instanceOfTpImplies(ProductClass.tpe, AnyRefTpe) def instanceOfTpImplies(tp: Type, tpImplied: Type) = { val tpValue = tp.typeSymbol.isPrimitiveValueClass @@ -28,7 +28,7 @@ trait TreeAndTypeAnalysis extends Debugging { // this allows us to reuse subtyping as a model for implication between instanceOf tests // the latter don't see a difference between AnyRef, Object or Any when comparing non-value types -- SI-6022 val tpImpliedNormalizedToAny = - if (tpImplied =:= (if (tpValue) AnyValClass.tpe else AnyRefClass.tpe)) AnyClass.tpe + if (tpImplied =:= (if (tpValue) AnyValTpe else AnyRefTpe)) AnyTpe else tpImplied tp <:< tpImpliedNormalizedToAny @@ -48,7 +48,7 @@ trait TreeAndTypeAnalysis extends Debugging { tp.typeSymbol match { // TODO case _ if tp.isTupleType => // recurse into component types? case UnitClass => - Some(List(UnitClass.tpe)) + Some(List(UnitTpe)) case BooleanClass => Some((List(ConstantType(Constant(true)), ConstantType(Constant(false))))) // TODO case _ if tp.isTupleType => // recurse into component types diff --git a/src/compiler/scala/tools/nsc/transform/patmat/MatchCodeGen.scala b/src/compiler/scala/tools/nsc/transform/patmat/MatchCodeGen.scala index 889615a39f..1e4c56529c 100644 --- a/src/compiler/scala/tools/nsc/transform/patmat/MatchCodeGen.scala +++ b/src/compiler/scala/tools/nsc/transform/patmat/MatchCodeGen.scala @@ -128,7 +128,7 @@ trait MatchCodeGen extends Interface { // __match.guard(`cond`, `res`).flatMap(`nextBinder` => `next`) def flatMapCond(cond: Tree, res: Tree, nextBinder: Symbol, next: Tree): Tree = flatMap(guard(cond, res), nextBinder, next) // __match.guard(`guardTree`, ()).flatMap((_: P[Unit]) => `next`) - def flatMapGuard(guardTree: Tree, next: Tree): Tree = flatMapCond(guardTree, CODE.UNIT, freshSym(guardTree.pos, pureType(UnitClass.tpe)), next) + def flatMapGuard(guardTree: Tree, next: Tree): Tree = flatMapCond(guardTree, CODE.UNIT, freshSym(guardTree.pos, pureType(UnitTpe)), next) } } diff --git a/src/compiler/scala/tools/nsc/transform/patmat/MatchOptimization.scala b/src/compiler/scala/tools/nsc/transform/patmat/MatchOptimization.scala index 31b04d0bd6..9854e4ef62 100644 --- a/src/compiler/scala/tools/nsc/transform/patmat/MatchOptimization.scala +++ b/src/compiler/scala/tools/nsc/transform/patmat/MatchOptimization.scala @@ -143,7 +143,7 @@ trait MatchOptimization extends MatchTreeMaking with MatchAnalysis { } class ReusedCondTreeMaker(prevBinder: Symbol, val nextBinder: Symbol, cond: Tree, res: Tree, val pos: Position) extends TreeMaker { import CODE._ lazy val localSubstitution = Substitution(List(prevBinder), List(CODE.REF(nextBinder))) - lazy val storedCond = freshSym(pos, BooleanClass.tpe, "rc") setFlag MUTABLE + lazy val storedCond = freshSym(pos, BooleanTpe, "rc") setFlag MUTABLE lazy val treesToHoist: List[Tree] = { nextBinder setFlag MUTABLE List(storedCond, nextBinder) map { b => VAL(b) === codegen.mkZero(b.info) } @@ -503,7 +503,7 @@ trait MatchOptimization extends MatchTreeMaking with MatchAnalysis { } class RegularSwitchMaker(scrutSym: Symbol, matchFailGenOverride: Option[Tree => Tree], val unchecked: Boolean) extends SwitchMaker { - val switchableTpe = Set(ByteClass.tpe, ShortClass.tpe, IntClass.tpe, CharClass.tpe) + val switchableTpe = Set(ByteTpe, ShortTpe, IntTpe, CharTpe) val alternativesSupported = true val canJump = true @@ -543,7 +543,7 @@ trait MatchOptimization extends MatchTreeMaking with MatchAnalysis { else { // match on scrutSym -- converted to an int if necessary -- not on scrut directly (to avoid duplicating scrut) val scrutToInt: Tree = - if (scrutSym.tpe =:= IntClass.tpe) REF(scrutSym) + if (scrutSym.tpe =:= IntTpe) REF(scrutSym) else (REF(scrutSym) DOT (nme.toInt)) Some(BLOCK( VAL(scrutSym) === scrut, @@ -571,16 +571,16 @@ trait MatchOptimization extends MatchTreeMaking with MatchAnalysis { } def isDefault(x: CaseDef): Boolean = x match { - case CaseDef(Typed(Ident(nme.WILDCARD), tpt), EmptyTree, _) if (tpt.tpe =:= ThrowableClass.tpe) => true - case CaseDef(Bind(_, Typed(Ident(nme.WILDCARD), tpt)), EmptyTree, _) if (tpt.tpe =:= ThrowableClass.tpe) => true + case CaseDef(Typed(Ident(nme.WILDCARD), tpt), EmptyTree, _) if (tpt.tpe =:= ThrowableTpe) => true + case CaseDef(Bind(_, Typed(Ident(nme.WILDCARD), tpt)), EmptyTree, _) if (tpt.tpe =:= ThrowableTpe) => true case CaseDef(Ident(nme.WILDCARD), EmptyTree, _) => true case _ => false } - lazy val defaultSym: Symbol = freshSym(NoPosition, ThrowableClass.tpe) + lazy val defaultSym: Symbol = freshSym(NoPosition, ThrowableTpe) def defaultBody: Tree = Throw(CODE.REF(defaultSym)) def defaultCase(scrutSym: Symbol = defaultSym, guard: Tree = EmptyTree, body: Tree = defaultBody): CaseDef = { import CODE._; atPos(body.pos) { - (CASE (Bind(scrutSym, Typed(Ident(nme.WILDCARD), TypeTree(ThrowableClass.tpe)))) IF guard) ==> body + (CASE (Bind(scrutSym, Typed(Ident(nme.WILDCARD), TypeTree(ThrowableTpe)))) IF guard) ==> body }} } diff --git a/src/compiler/scala/tools/nsc/transform/patmat/MatchTranslation.scala b/src/compiler/scala/tools/nsc/transform/patmat/MatchTranslation.scala index c8c3b741f1..fcee142932 100644 --- a/src/compiler/scala/tools/nsc/transform/patmat/MatchTranslation.scala +++ b/src/compiler/scala/tools/nsc/transform/patmat/MatchTranslation.scala @@ -14,14 +14,8 @@ import scala.reflect.internal.util.Statistics */ trait MatchTranslation { self: PatternMatching => import PatternMatchingStats._ - import global.{phase, currentRun, Symbol, - Apply, Bind, CaseDef, ClassInfoType, Ident, Literal, Match, - Alternative, Constant, EmptyTree, Select, Star, This, Throw, Typed, UnApply, - Type, MethodType, WildcardType, PolyType, ErrorType, NoType, TypeRef, typeRef, - Name, NoSymbol, Position, Tree, atPos, glb, rootMirror, treeInfo, nme, Transformer, - elimAnonymousClass, asCompactDebugString, hasLength, devWarning} - import global.definitions.{ThrowableClass, SeqClass, ScalaPackageClass, BooleanClass, UnitClass, RepeatedParamClass, - repeatedToSeq, isRepeatedParamType, getProductArgs} + import global._ + import definitions._ import global.analyzer.{ErrorUtils, formalTypes} trait MatchTranslator extends TreeMakers { @@ -169,7 +163,7 @@ trait MatchTranslation { self: PatternMatching => val bindersAndCases = caseDefs map { caseDef => // generate a fresh symbol for each case, hoping we'll end up emitting a type-switch (we don't have a global scrut there) // if we fail to emit a fine-grained switch, have to do translateCase again with a single scrutSym (TODO: uniformize substitution on treemakers so we can avoid this) - val caseScrutSym = freshSym(pos, pureType(ThrowableClass.tpe)) + val caseScrutSym = freshSym(pos, pureType(ThrowableTpe)) (caseScrutSym, propagateSubstitution(translateCase(caseScrutSym, pt)(caseDef), EmptySubstitution)) } @@ -179,10 +173,10 @@ trait MatchTranslation { self: PatternMatching => } val catches = if (swatches.nonEmpty) swatches else { - val scrutSym = freshSym(pos, pureType(ThrowableClass.tpe)) + val scrutSym = freshSym(pos, pureType(ThrowableTpe)) val casesNoSubstOnly = caseDefs map { caseDef => (propagateSubstitution(translateCase(scrutSym, pt)(caseDef), EmptySubstitution))} - val exSym = freshSym(pos, pureType(ThrowableClass.tpe), "ex") + val exSym = freshSym(pos, pureType(ThrowableTpe), "ex") List( atPos(pos) { @@ -194,7 +188,7 @@ trait MatchTranslation { self: PatternMatching => }) } - typer.typedCases(catches, ThrowableClass.tpe, WildcardType) + typer.typedCases(catches, ThrowableTpe, WildcardType) } @@ -595,7 +589,7 @@ trait MatchTranslation { self: PatternMatching => def treeMaker(patBinderOrCasted: Symbol, binderKnownNonNull: Boolean, pos: Position): TreeMaker = { // the extractor call (applied to the binder bound by the flatMap corresponding to the previous (i.e., enclosing/outer) pattern) val extractorApply = atPos(pos)(spliceApply(patBinderOrCasted)) - val binder = freshSym(pos, pureType(resultInMonad)) // can't simplify this when subPatBinders.isEmpty, since UnitClass.tpe is definitely wrong when isSeq, and resultInMonad should always be correct since it comes directly from the extractor's result type + val binder = freshSym(pos, pureType(resultInMonad)) // can't simplify this when subPatBinders.isEmpty, since UnitTpe is definitely wrong when isSeq, and resultInMonad should always be correct since it comes directly from the extractor's result type ExtractorTreeMaker(extractorApply, lengthGuard(binder), binder)(subPatBinders, subPatRefs(binder), resultType.typeSymbol == BooleanClass, checkedLength, patBinderOrCasted, ignoredSubPatBinders) } @@ -623,7 +617,7 @@ trait MatchTranslation { self: PatternMatching => // what's the extractor's result type in the monad? // turn an extractor's result type into something `monadTypeToSubPatTypesAndRefs` understands protected lazy val resultInMonad: Type = if(!hasLength(tpe.paramTypes, 1)) ErrorType else { - if (resultType.typeSymbol == BooleanClass) UnitClass.tpe + if (resultType.typeSymbol == BooleanClass) UnitTpe else matchMonadResult(resultType) } diff --git a/src/compiler/scala/tools/nsc/transform/patmat/MatchTreeMaking.scala b/src/compiler/scala/tools/nsc/transform/patmat/MatchTreeMaking.scala index 4dff445fe8..bce0a077fb 100644 --- a/src/compiler/scala/tools/nsc/transform/patmat/MatchTreeMaking.scala +++ b/src/compiler/scala/tools/nsc/transform/patmat/MatchTreeMaking.scala @@ -19,7 +19,7 @@ import scala.reflect.internal.util.Position */ trait MatchTreeMaking extends MatchCodeGen with Debugging { import global._ - import definitions.{SomeClass, AnyRefClass, UncheckedClass, BooleanClass} + import definitions._ final case class Suppression(exhaustive: Boolean, unreachable: Boolean) object Suppression { @@ -414,7 +414,7 @@ trait MatchTreeMaking extends MatchCodeGen with Debugging { case SingleType(_, sym) => and(equalsTest(gen.mkAttributedQualifier(expectedTp), testedBinder), typeTest(testedBinder, expectedTp.widen)) // must use == to support e.g. List() == Nil case ThisType(sym) if sym.isModule => and(equalsTest(CODE.REF(sym), testedBinder), typeTest(testedBinder, expectedTp.widen)) - case ConstantType(Constant(null)) if testedBinder.info.widen <:< AnyRefClass.tpe + case ConstantType(Constant(null)) if testedBinder.info.widen <:< AnyRefTpe => eqTest(expTp(CODE.NULL), testedBinder) case ConstantType(const) => equalsTest(expTp(Literal(const)), testedBinder) case ThisType(sym) => eqTest(expTp(This(sym)), testedBinder) @@ -428,7 +428,7 @@ trait MatchTreeMaking extends MatchCodeGen with Debugging { // since the types conform, no further checking is required if (expectedTp.typeSymbol.isPrimitiveValueClass) tru // have to test outer and non-null only when it's a reference type - else if (expectedTp <:< AnyRefClass.tpe) { + else if (expectedTp <:< AnyRefTpe) { // do non-null check first to ensure we won't select outer on null if (outerTestNeeded) and(nonNullTest(testedBinder), outerTest(testedBinder, expectedTp)) else nonNullTest(testedBinder) @@ -476,7 +476,7 @@ trait MatchTreeMaking extends MatchCodeGen with Debugging { ((casegen: Casegen) => combineExtractors(altTreeMakers :+ TrivialTreeMaker(casegen.one(mkTRUE)))(casegen)) ) - val findAltMatcher = codegenAlt.matcher(EmptyTree, NoSymbol, BooleanClass.tpe)(combinedAlts, Some(x => mkFALSE)) + val findAltMatcher = codegenAlt.matcher(EmptyTree, NoSymbol, BooleanTpe)(combinedAlts, Some(x => mkFALSE)) codegenAlt.ifThenElseZero(findAltMatcher, substitution(next)) } } diff --git a/src/compiler/scala/tools/nsc/typechecker/AnalyzerPlugins.scala b/src/compiler/scala/tools/nsc/typechecker/AnalyzerPlugins.scala index 4210d0b9fb..54e4fefc15 100644 --- a/src/compiler/scala/tools/nsc/typechecker/AnalyzerPlugins.scala +++ b/src/compiler/scala/tools/nsc/typechecker/AnalyzerPlugins.scala @@ -146,7 +146,7 @@ trait AnalyzerPlugins { self: Analyzer => /** * Modify the type of a return expression. By default, return expressions have type - * NothingClass.tpe. + * NothingTpe. * * @param tpe The type of the return expression * @param typer The typer that was used for typing the return tree diff --git a/src/compiler/scala/tools/nsc/typechecker/Checkable.scala b/src/compiler/scala/tools/nsc/typechecker/Checkable.scala index 0686b28079..31a31df764 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Checkable.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Checkable.scala @@ -247,7 +247,7 @@ trait Checkable { case TypeRef(_, NothingClass | NullClass | AnyValClass, _) => false case RefinedType(_, decls) if !decls.isEmpty => false case p => - new CheckabilityChecker(AnyClass.tpe, p) isCheckable + new CheckabilityChecker(AnyTpe, p) isCheckable }) ) diff --git a/src/compiler/scala/tools/nsc/typechecker/ContextErrors.scala b/src/compiler/scala/tools/nsc/typechecker/ContextErrors.scala index 9a18248929..135a79124d 100644 --- a/src/compiler/scala/tools/nsc/typechecker/ContextErrors.scala +++ b/src/compiler/scala/tools/nsc/typechecker/ContextErrors.scala @@ -71,7 +71,7 @@ trait ContextErrors { extends TreeTypeError { def errMsg: String = errMsgForPt(pt0) def withPt(pt: Type): AbsTypeError = this.copy(pt0 = pt) - private def errMsgForPt(pt: Type) = + private def errMsgForPt(pt: Type) = s"diverging implicit expansion for type ${pt}\nstarting with ${sym.fullLocationString}" } @@ -1145,7 +1145,7 @@ trait ContextErrors { // failures which have nothing to do with implicit conversions // per se, but which manifest as implicit conversion conflicts // involving Any, are further explained from foundReqMsg. - if (AnyRefClass.tpe <:< req) ( + if (AnyRefTpe <:< req) ( if (sym == AnyClass || sym == UnitClass) ( sm"""|Note: ${sym.name} is not implicitly converted to AnyRef. You can safely |pattern match `x: AnyRef` or cast `x.asInstanceOf[AnyRef]` to do so.""" diff --git a/src/compiler/scala/tools/nsc/typechecker/Duplicators.scala b/src/compiler/scala/tools/nsc/typechecker/Duplicators.scala index aa05c97c08..95b771a8a5 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Duplicators.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Duplicators.scala @@ -17,7 +17,7 @@ import scala.collection.{ mutable, immutable } */ abstract class Duplicators extends Analyzer { import global._ - import definitions.{ AnyRefClass, AnyValClass } + import definitions._ /** Retype the given tree in the given context. Use this method when retyping * a method in a different class. The typer will replace references to the this of @@ -346,8 +346,8 @@ abstract class Duplicators extends Analyzer { // Without this, AnyRef specializations crash on patterns like // case _: Boolean => ... // Not at all sure this is safe. - else if (scrutTpe <:< AnyRefClass.tpe) - cases filterNot (_.pat.tpe <:< AnyValClass.tpe) + else if (scrutTpe <:< AnyRefTpe) + cases filterNot (_.pat.tpe <:< AnyValTpe) else cases } @@ -361,7 +361,7 @@ abstract class Duplicators extends Analyzer { case _ => debuglog("Duplicators default case: " + tree.summaryString) debuglog(" ---> " + tree) - if (tree.hasSymbolField && tree.symbol != NoSymbol && (tree.symbol.owner == definitions.AnyClass)) { + if (tree.hasSymbolField && tree.symbol != NoSymbol && (tree.symbol.owner == AnyClass)) { tree.symbol = NoSymbol // maybe we can find a more specific member in a subclass of Any (see AnyVal members, like ==) } val ntree = castType(tree, pt) diff --git a/src/compiler/scala/tools/nsc/typechecker/Implicits.scala b/src/compiler/scala/tools/nsc/typechecker/Implicits.scala index 37257b4f4e..a6a3a4911f 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Implicits.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Implicits.scala @@ -131,7 +131,7 @@ trait Implicits { val tvars = tpars map (TypeVar untouchable _) val tpSubsted = tp.subst(tpars, tvars) - val search = new ImplicitSearch(EmptyTree, functionType(List(tpSubsted), AnyClass.tpe), true, context.makeImplicit(reportAmbiguousErrors = false)) + val search = new ImplicitSearch(EmptyTree, functionType(List(tpSubsted), AnyTpe), true, context.makeImplicit(reportAmbiguousErrors = false)) search.allImplicitsPoly(tvars) } @@ -1259,8 +1259,8 @@ trait Implicits { // looking for a manifest of a type parameter that hasn't been inferred by now, // can't do much, but let's not fail else if (undetParams contains sym) { - // #3859: need to include the mapping from sym -> NothingClass.tpe in the SearchResult - mot(NothingClass.tpe, sym :: from, NothingClass.tpe :: to) + // #3859: need to include the mapping from sym -> NothingTpe in the SearchResult + mot(NothingTpe, sym :: from, NothingTpe :: to) } else { // a manifest should have been found by normal searchImplicit EmptyTree diff --git a/src/compiler/scala/tools/nsc/typechecker/Infer.scala b/src/compiler/scala/tools/nsc/typechecker/Infer.scala index 3abbfbd00c..961ef484d8 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Infer.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Infer.scala @@ -531,7 +531,7 @@ trait Infer extends Checkable { def unapply(m: Result): Some[(List[Symbol], List[Type], List[Type], List[Symbol])] = Some(toLists{ val (ok, nok) = m.map{case (p, a) => (p, a.getOrElse(null))}.partition(_._2 ne null) val (okArgs, okTparams) = ok.unzip - (okArgs, okTparams, m.values.map(_.getOrElse(NothingClass.tpe)), nok.keys) + (okArgs, okTparams, m.values.map(_.getOrElse(NothingTpe)), nok.keys) }) } @@ -581,7 +581,7 @@ trait Infer extends Checkable { /** Return inferred type arguments, given type parameters, formal parameters, * argument types, result type and expected result type. * If this is not possible, throw a `NoInstance` exception. - * Undetermined type arguments are represented by `definitions.NothingClass.tpe`. + * Undetermined type arguments are represented by `definitions.NothingTpe`. * No check that inferred parameters conform to their bounds is made here. * * @param tparams the type parameters of the method @@ -725,7 +725,7 @@ trait Infer extends Checkable { if (pos == -1) { if (positionalAllowed) { // treat assignment as positional argument argPos(index) = index - res = UnitClass.tpe + res = UnitTpe } else // unknown parameter name namesOK = false } else if (argPos.contains(pos)) { // parameter specified twice @@ -773,10 +773,10 @@ trait Infer extends Checkable { * @pre: the argument list is eligible for tuple conversion. */ private def typeAfterTupleConversion(argtpes: List[Type]): Type = ( - if (argtpes.isEmpty) UnitClass.tpe // aka "Tuple0" + if (argtpes.isEmpty) UnitTpe // aka "Tuple0" else tupleType(argtpes map { - case NamedType(name, tp) => UnitClass.tpe // not a named arg - only assignments here - case RepeatedType(tp) => tp // but probably shouldn't be tupling a call containing :_* + case NamedType(name, tp) => UnitTpe // not a named arg - only assignments here + case RepeatedType(tp) => tp // but probably shouldn't be tupling a call containing :_* case tp => tp }) ) diff --git a/src/compiler/scala/tools/nsc/typechecker/MethodSynthesis.scala b/src/compiler/scala/tools/nsc/typechecker/MethodSynthesis.scala index 50383a1e78..cc3a43a66e 100644 --- a/src/compiler/scala/tools/nsc/typechecker/MethodSynthesis.scala +++ b/src/compiler/scala/tools/nsc/typechecker/MethodSynthesis.scala @@ -103,7 +103,7 @@ trait MethodSynthesis { createMethod(original)(m => gen.mkMethodCall(newMethod, transformArgs(m.paramss.head map Ident))) def createSwitchMethod(name: Name, range: Seq[Int], returnType: Type)(f: Int => Tree) = { - createMethod(name, List(IntClass.tpe), returnType) { m => + createMethod(name, List(IntTpe), returnType) { m => val arg0 = Ident(m.firstParam) val default = DEFAULT ==> THROW(IndexOutOfBoundsExceptionClass, arg0) val cases = range.map(num => CASE(LIT(num)) ==> f(num)).toList :+ default diff --git a/src/compiler/scala/tools/nsc/typechecker/Namers.scala b/src/compiler/scala/tools/nsc/typechecker/Namers.scala index 55f144da13..9efb54d6cd 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Namers.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Namers.scala @@ -765,7 +765,7 @@ trait Namers extends MethodSynthesis { def accessorTypeCompleter(tree: ValDef, isSetter: Boolean) = mkTypeCompleter(tree) { sym => logAndValidate(sym) { sym setInfo { - val tp = if (isSetter) MethodType(List(sym.newSyntheticValueParam(typeSig(tree))), UnitClass.tpe) + val tp = if (isSetter) MethodType(List(sym.newSyntheticValueParam(typeSig(tree))), UnitTpe) else NullaryMethodType(typeSig(tree)) pluginsTypeSigAccessor(tp, typer, tree, sym) } @@ -863,7 +863,7 @@ trait Namers extends MethodSynthesis { private def templateSig(templ: Template): Type = { val clazz = context.owner def checkParent(tpt: Tree): Type = { - if (tpt.tpe.isError) AnyRefClass.tpe + if (tpt.tpe.isError) AnyRefTpe else tpt.tpe } @@ -1493,8 +1493,8 @@ trait Namers extends MethodSynthesis { private object RestrictJavaArraysMap extends TypeMap { def apply(tp: Type): Type = tp match { case TypeRef(pre, ArrayClass, List(elemtp)) - if elemtp.typeSymbol.isAbstractType && !(elemtp <:< ObjectClass.tpe) => - TypeRef(pre, ArrayClass, List(intersectionType(List(elemtp, ObjectClass.tpe)))) + if elemtp.typeSymbol.isAbstractType && !(elemtp <:< ObjectTpe) => + TypeRef(pre, ArrayClass, List(intersectionType(List(elemtp, ObjectTpe)))) case _ => mapOver(tp) } diff --git a/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala b/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala index 50b92f13ab..407eb3ac18 100644 --- a/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala +++ b/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala @@ -748,7 +748,7 @@ abstract class RefChecks extends InfoTransform with scala.reflect.internal.trans // Have to use matchingSymbol, not a method involving overridden symbols, // because the scala type system understands that an abstract method here does not // override a concrete method in Object. The jvm, however, does not. - val overridden = decl.matchingSymbol(ObjectClass, ObjectClass.tpe) + val overridden = decl.matchingSymbol(ObjectClass, ObjectTpe) if (overridden.isFinal) unit.error(decl.pos, "trait cannot redefine final method from class AnyRef") } @@ -996,7 +996,7 @@ abstract class RefChecks extends InfoTransform with scala.reflect.internal.trans // equals method inherited from Object or a case class synthetic equals (for // which we know the logic.) def isWarnable = isReferenceOp || (isUsingDefaultScalaOp && isUsingWarnableEquals) - def isEitherNullable = (NullClass.tpe <:< receiver.info) || (NullClass.tpe <:< actual.info) + def isEitherNullable = (NullTpe <:< receiver.info) || (NullTpe <:< actual.info) def isEitherValueClass = actual.isDerivedValueClass || receiver.isDerivedValueClass def isBoolean(s: Symbol) = unboxedValueClass(s) == BooleanClass def isUnit(s: Symbol) = unboxedValueClass(s) == UnitClass @@ -1081,7 +1081,7 @@ abstract class RefChecks extends InfoTransform with scala.reflect.internal.trans // better to have lubbed and lost def warnIfLubless(): Unit = { val common = global.lub(List(actual.tpe, receiver.tpe)) - if (ObjectClass.tpe <:< common) + if (ObjectTpe <:< common) unrelatedTypes() } // warn if actual has a case parent that is not same as receiver's; @@ -1533,7 +1533,7 @@ abstract class RefChecks extends InfoTransform with scala.reflect.internal.trans private def transformIf(tree: If): Tree = { val If(cond, thenpart, elsepart) = tree def unitIfEmpty(t: Tree): Tree = - if (t == EmptyTree) Literal(Constant(())).setPos(tree.pos).setType(UnitClass.tpe) else t + if (t == EmptyTree) Literal(Constant(())).setPos(tree.pos).setType(UnitTpe) else t cond.tpe match { case ConstantType(value) => diff --git a/src/compiler/scala/tools/nsc/typechecker/SuperAccessors.scala b/src/compiler/scala/tools/nsc/typechecker/SuperAccessors.scala index 4e78cecd7d..6933b10a0a 100644 --- a/src/compiler/scala/tools/nsc/typechecker/SuperAccessors.scala +++ b/src/compiler/scala/tools/nsc/typechecker/SuperAccessors.scala @@ -30,7 +30,7 @@ import symtab.Flags._ */ abstract class SuperAccessors extends transform.Transform with transform.TypingTransformers { import global._ - import definitions.{ UnitClass, ObjectClass, isRepeatedParamType, isByNameParamType, Any_asInstanceOf } + import definitions._ import analyzer.{ restrictionError } /** the following two members override abstract members in Transform */ @@ -458,7 +458,7 @@ abstract class SuperAccessors extends transform.Transform with transform.TypingT val protAcc = clazz.newMethod(accName, field.pos, newFlags = ARTIFACT) val paramTypes = List(clazz.typeOfThis, field.tpe) val params = protAcc newSyntheticValueParams paramTypes - val accessorType = MethodType(params, UnitClass.tpe) + val accessorType = MethodType(params, UnitTpe) protAcc setInfoAndEnter accessorType val obj :: value :: Nil = params diff --git a/src/compiler/scala/tools/nsc/typechecker/SyntheticMethods.scala b/src/compiler/scala/tools/nsc/typechecker/SyntheticMethods.scala index 406bc445c9..4ff3c39df3 100644 --- a/src/compiler/scala/tools/nsc/typechecker/SyntheticMethods.scala +++ b/src/compiler/scala/tools/nsc/typechecker/SyntheticMethods.scala @@ -100,7 +100,7 @@ trait SyntheticMethods extends ast.TreeDSL { case tp => tp } } - else AnyClass.tpe + else AnyTpe ) def forwardToRuntime(method: Symbol): Tree = @@ -131,7 +131,7 @@ trait SyntheticMethods extends ast.TreeDSL { def perElementMethod(name: Name, returnType: Type)(caseFn: Symbol => Tree): Tree = createSwitchMethod(name, accessors.indices, returnType)(idx => caseFn(accessors(idx))) - // def productElementNameMethod = perElementMethod(nme.productElementName, StringClass.tpe)(x => LIT(x.name.toString)) + // def productElementNameMethod = perElementMethod(nme.productElementName, StringTpe)(x => LIT(x.name.toString)) var syntheticCanEqual = false @@ -140,7 +140,7 @@ trait SyntheticMethods extends ast.TreeDSL { */ def canEqualMethod: Tree = { syntheticCanEqual = true - createMethod(nme.canEqual_, List(AnyClass.tpe), BooleanClass.tpe)(m => + createMethod(nme.canEqual_, List(AnyTpe), BooleanTpe)(m => Ident(m.firstParam) IS_OBJ classExistentialType(clazz)) } @@ -200,7 +200,7 @@ trait SyntheticMethods extends ast.TreeDSL { * } * } */ - def equalsCaseClassMethod: Tree = createMethod(nme.equals_, List(AnyClass.tpe), BooleanClass.tpe) { m => + def equalsCaseClassMethod: Tree = createMethod(nme.equals_, List(AnyTpe), BooleanTpe) { m => if (accessors.isEmpty) if (clazz.isFinal) thatTest(m) else thatTest(m) AND ((thatCast(m) DOT nme.canEqual_)(mkThis)) @@ -214,14 +214,14 @@ trait SyntheticMethods extends ast.TreeDSL { * val x$1 = that.asInstanceOf[this.C] * (this.underlying == that.underlying */ - def equalsDerivedValueClassMethod: Tree = createMethod(nme.equals_, List(AnyClass.tpe), BooleanClass.tpe) { m => + def equalsDerivedValueClassMethod: Tree = createMethod(nme.equals_, List(AnyTpe), BooleanTpe) { m => equalsCore(m, List(clazz.derivedValueClassUnbox)) } /* The hashcode method for value classes * def hashCode(): Int = this.underlying.hashCode */ - def hashCodeDerivedValueClassMethod: Tree = createMethod(nme.hashCode_, Nil, IntClass.tpe) { m => + def hashCodeDerivedValueClassMethod: Tree = createMethod(nme.hashCode_, Nil, IntTpe) { m => Select(mkThisSelect(clazz.derivedValueClassUnbox), nme.hashCode_) } @@ -265,8 +265,8 @@ trait SyntheticMethods extends ast.TreeDSL { } def specializedHashcode = { - createMethod(nme.hashCode_, Nil, IntClass.tpe) { m => - val accumulator = m.newVariable(newTermName("acc"), m.pos, SYNTHETIC) setInfo IntClass.tpe + createMethod(nme.hashCode_, Nil, IntTpe) { m => + val accumulator = m.newVariable(newTermName("acc"), m.pos, SYNTHETIC) setInfo IntTpe val valdef = ValDef(accumulator, Literal(Constant(0xcafebabe))) val mixes = accessors map (acc => Assign( @@ -356,7 +356,7 @@ trait SyntheticMethods extends ast.TreeDSL { // This method should be generated as private, but apparently if it is, then // it is name mangled afterward. (Wonder why that is.) So it's only protected. // For sure special methods like "readResolve" should not be mangled. - List(createMethod(nme.readResolve, Nil, ObjectClass.tpe)(m => { m setFlag PRIVATE ; REF(clazz.sourceModule) })) + List(createMethod(nme.readResolve, Nil, ObjectTpe)(m => { m setFlag PRIVATE ; REF(clazz.sourceModule) })) } else Nil ) diff --git a/src/compiler/scala/tools/nsc/typechecker/Tags.scala b/src/compiler/scala/tools/nsc/typechecker/Tags.scala index d2d7f57aef..32a66aa4dd 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Tags.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Tags.scala @@ -30,7 +30,7 @@ trait Tags { * However we found out that we don't really need this concept, so it got removed. * * @param pos Position for error reporting. Please, provide meaningful value. - * @param tp Type we're looking a ClassTag for, e.g. resolveClassTag(pos, IntClass.tpe) will look for ClassTag[Int]. + * @param tp Type we're looking a ClassTag for, e.g. resolveClassTag(pos, IntTpe) will look for ClassTag[Int]. * @param allowMaterialization If true (default) then the resolver is allowed to launch materialization macros when there's no class tag in scope. * If false then materialization macros are prohibited from running. * @@ -49,7 +49,7 @@ trait Tags { * @param pre Prefix that represents a universe this type tag will be bound to. * If `pre` is set to `NoType`, then any type tag in scope will do, regardless of its affiliation. * If `pre` is set to `NoType`, and tag resolution involves materialization, then `mkRuntimeUniverseRef` will be used. - * @param tp Type we're looking a TypeTag for, e.g. resolveTypeTag(pos, mkRuntimeUniverseRef, IntClass.tpe, false) will look for scala.reflect.runtime.universe.TypeTag[Int]. + * @param tp Type we're looking a TypeTag for, e.g. resolveTypeTag(pos, mkRuntimeUniverseRef, IntTpe, false) will look for scala.reflect.runtime.universe.TypeTag[Int]. * @param concrete If true then the result must not contain unresolved (i.e. not spliced) type parameters and abstract type members. * If false then the function will always succeed (abstract types will be reified as free types). * @param allowMaterialization If true (default) then the resolver is allowed to launch materialization macros when there's no type tag in scope. @@ -69,4 +69,4 @@ trait Tags { resolveTag(pos, taggedTp, allowMaterialization) } } -}
\ No newline at end of file +} diff --git a/src/compiler/scala/tools/nsc/typechecker/TypeDiagnostics.scala b/src/compiler/scala/tools/nsc/typechecker/TypeDiagnostics.scala index b2a6e7340d..5d790ba835 100644 --- a/src/compiler/scala/tools/nsc/typechecker/TypeDiagnostics.scala +++ b/src/compiler/scala/tools/nsc/typechecker/TypeDiagnostics.scala @@ -253,7 +253,7 @@ trait TypeDiagnostics { // For found/required errors where AnyRef would have sufficed: // explain in greater detail. def explainAnyVsAnyRef(found: Type, req: Type): String = { - if (AnyRefClass.tpe <:< req) notAnyRefMessage(found) else "" + if (AnyRefTpe <:< req) notAnyRefMessage(found) else "" } // TODO - figure out how to avoid doing any work at all diff --git a/src/compiler/scala/tools/nsc/typechecker/Typers.scala b/src/compiler/scala/tools/nsc/typechecker/Typers.scala index b7e0d44e96..0b541c24c1 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Typers.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Typers.scala @@ -1147,7 +1147,7 @@ trait Typers extends Adaptations with Tags { if (mode.typingExprNotFun) { // The <: Any requirement inhibits attempts to adapt continuation types // to non-continuation types. - if (tree.tpe <:< AnyClass.tpe) pt.dealias match { + if (tree.tpe <:< AnyTpe) pt.dealias match { case TypeRef(_, UnitClass, _) => // (12) if (settings.warnValueDiscard) context.unit.warning(tree.pos, "discarded non-Unit value") @@ -1284,10 +1284,10 @@ trait Typers extends Adaptations with Tags { */ def instantiateExpectingUnit(tree: Tree, mode: Mode): Tree = { val savedUndetparams = context.undetparams - silent(_.instantiate(tree, mode, UnitClass.tpe)) orElse { _ => + silent(_.instantiate(tree, mode, UnitTpe)) orElse { _ => context.undetparams = savedUndetparams val valueDiscard = atPos(tree.pos)(Block(List(instantiate(tree, mode, WildcardType)), Literal(Constant(())))) - typed(valueDiscard, mode, UnitClass.tpe) + typed(valueDiscard, mode, UnitTpe) } } @@ -1708,7 +1708,7 @@ trait Typers extends Adaptations with Tags { } def typedParentTypes(templ: Template): List[Tree] = templ.parents match { - case Nil => List(atPos(templ.pos)(TypeTree(AnyRefClass.tpe))) + case Nil => List(atPos(templ.pos)(TypeTree(AnyRefTpe))) case first :: rest => try { val supertpts = fixDuplicateSyntheticParents(normalizeFirstParent( @@ -1734,7 +1734,7 @@ trait Typers extends Adaptations with Tags { log("Type error calculating parents in template " + templ) log("Error: " + ex) ParentTypesError(templ, ex) - List(TypeTree(AnyRefClass.tpe)) + List(TypeTree(AnyRefTpe)) } } @@ -1820,7 +1820,7 @@ trait Typers extends Adaptations with Tags { for (tparam <- clazz.typeParams) { if (classinfo.expansiveRefs(tparam) contains tparam) { val newinfo = ClassInfoType( - classinfo.parents map (_.instantiateTypeParams(List(tparam), List(AnyRefClass.tpe))), + classinfo.parents map (_.instantiateTypeParams(List(tparam), List(AnyRefTpe))), classinfo.decls, clazz) clazz.setInfo { @@ -1886,7 +1886,7 @@ trait Typers extends Adaptations with Tags { if (noSerializable) Nil else { clazz.makeSerializable() - List(TypeTree(SerializableClass.tpe) setPos clazz.pos.focus) + List(TypeTree(SerializableTpe) setPos clazz.pos.focus) } ) }) @@ -2377,7 +2377,7 @@ trait Typers extends Adaptations with Tags { case ldef @ LabelDef(_, _, _) => if (ldef.symbol == NoSymbol) ldef.symbol = namer.enterInScope( - context.owner.newLabel(ldef.name, ldef.pos) setInfo MethodType(List(), UnitClass.tpe)) + context.owner.newLabel(ldef.name, ldef.pos) setInfo MethodType(List(), UnitTpe)) case _ => } } @@ -2500,7 +2500,7 @@ trait Typers extends Adaptations with Tags { namer.enterIfNotThere(bind.symbol) val guard1: Tree = if (cdef.guard == EmptyTree) EmptyTree - else typed(cdef.guard, BooleanClass.tpe) + else typed(cdef.guard, BooleanTpe) var body1: Tree = typed(cdef.body, pt) if (context.enclosingCaseDef.savedTypeBounds.nonEmpty) { @@ -2597,7 +2597,7 @@ trait Typers extends Adaptations with Tags { val argTp :: resTp :: Nil = targs // targs must conform to Any for us to synthesize an applyOrElse (fallback to apply otherwise -- typically for @cps annotated targs) - val targsValidParams = targs forall (_ <:< AnyClass.tpe) + val targsValidParams = targs forall (_ <:< AnyTpe) val anonClass = (context.owner newAnonymousFunctionClass tree.pos @@ -2725,12 +2725,12 @@ trait Typers extends Adaptations with Tags { val methodBodyTyper = newTyper(context.makeNewScope(context.tree, methodSym)) // should use the DefDef for the context's tree, but it doesn't exist yet (we need the typer we're creating to create it) methodBodyTyper.context.scope enter paramSym - methodSym setInfo MethodType(List(paramSym), BooleanClass.tpe) + methodSym setInfo MethodType(List(paramSym), BooleanTpe) val defaultCase = mkDefaultCase(FALSE) - val match_ = methodBodyTyper.typedMatch(selector, casesTrue :+ defaultCase, mode, BooleanClass.tpe) + val match_ = methodBodyTyper.typedMatch(selector, casesTrue :+ defaultCase, mode, BooleanTpe) - DefDef(methodSym, methodBodyTyper.virtualizedMatch(match_, mode, BooleanClass.tpe)) + DefDef(methodSym, methodBodyTyper.virtualizedMatch(match_, mode, BooleanTpe)) } // only used for @cps annotated partial functions @@ -2739,7 +2739,7 @@ trait Typers extends Adaptations with Tags { val methodSym = anonClass.newMethod(nme.apply, tree.pos, FINAL | OVERRIDE) val paramSym = mkParam(methodSym) - methodSym setInfo MethodType(List(paramSym), AnyClass.tpe) + methodSym setInfo MethodType(List(paramSym), AnyTpe) val methodBodyTyper = newTyper(context.makeNewScope(context.tree, methodSym)) // should use the DefDef for the context's tree, but it doesn't exist yet (we need the typer we're creating to create it) @@ -3106,11 +3106,11 @@ trait Typers extends Adaptations with Tags { // less expensive than including them in inferMethodAlternative (see below). def shapeType(arg: Tree): Type = arg match { case Function(vparams, body) => - functionType(vparams map (_ => AnyClass.tpe), shapeType(body)) + functionType(vparams map (_ => AnyTpe), shapeType(body)) case AssignOrNamedArg(Ident(name), rhs) => NamedType(name, shapeType(rhs)) case _ => - NothingClass.tpe + NothingTpe } val argtypes = args map shapeType val pre = fun.symbol.tpe.prefix @@ -3872,7 +3872,7 @@ trait Typers extends Adaptations with Tags { // as we don't know which alternative to choose... here we do map2Conserve(args, tparams) { //@M! the polytype denotes the expected kind - (arg, tparam) => typedHigherKindedType(arg, mode, GenPolyType(tparam.typeParams, AnyClass.tpe)) + (arg, tparam) => typedHigherKindedType(arg, mode, GenPolyType(tparam.typeParams, AnyTpe)) } } else // @M: there's probably something wrong when args.length != tparams.length... (triggered by bug #320) // Martin, I'm using fake trees, because, if you use args or arg.map(typedType), @@ -3893,7 +3893,7 @@ trait Typers extends Adaptations with Tags { if (!isPastTyper && fun.symbol == Any_isInstanceOf && targs.nonEmpty) { val scrutineeType = fun match { case Select(qual, _) => qual.tpe - case _ => AnyClass.tpe + case _ => AnyTpe } checkCheckable(tree, targs.head, scrutineeType, inPattern = false) } @@ -4218,7 +4218,7 @@ trait Typers extends Adaptations with Tags { // (phase.erasedTypes && varsym.isValue && !varsym.isMethod)) { if (varsym.isVariable || varsym.isValue && phase.erasedTypes) { val rhs1 = typedByValueExpr(rhs, lhs1.tpe) - treeCopy.Assign(tree, lhs1, checkDead(rhs1)) setType UnitClass.tpe + treeCopy.Assign(tree, lhs1, checkDead(rhs1)) setType UnitTpe } else if(dyna.isDynamicallyUpdatable(lhs1)) { val rhs1 = typedByValueExpr(rhs) @@ -4229,10 +4229,10 @@ trait Typers extends Adaptations with Tags { } def typedIf(tree: If): If = { - val cond1 = checkDead(typedByValueExpr(tree.cond, BooleanClass.tpe)) + val cond1 = checkDead(typedByValueExpr(tree.cond, BooleanTpe)) // One-legged ifs don't need a lot of analysis if (tree.elsep.isEmpty) - return treeCopy.If(tree, cond1, typed(tree.thenp, UnitClass.tpe), tree.elsep) setType UnitClass.tpe + return treeCopy.If(tree, cond1, typed(tree.thenp, UnitTpe), tree.elsep) setType UnitTpe val thenp1 = typed(tree.thenp, pt) val elsep1 = typed(tree.elsep, pt) @@ -4313,7 +4313,7 @@ trait Typers extends Adaptations with Tags { unit.warning(tree.pos, "enclosing method " + name + " has result type Unit: return value discarded") } val res = treeCopy.Return(tree, checkDead(expr1)).setSymbol(enclMethod.owner) - val tp = pluginsTypedReturn(NothingClass.tpe, this, res, restpt.tpe) + val tp = pluginsTypedReturn(NothingTpe, this, res, restpt.tpe) res.setType(tp) } } @@ -4916,7 +4916,7 @@ trait Typers extends Adaptations with Tags { // if symbol hasn't been fully loaded, can't check kind-arity else map2Conserve(args, tparams) { (arg, tparam) => //@M! the polytype denotes the expected kind - typedHigherKindedType(arg, mode, GenPolyType(tparam.typeParams, AnyClass.tpe)) + typedHigherKindedType(arg, mode, GenPolyType(tparam.typeParams, AnyTpe)) } val argtypes = args1 map (_.tpe) @@ -5038,8 +5038,8 @@ trait Typers extends Adaptations with Tags { def typedTry(tree: Try) = { val Try(block, catches, fin) = tree val block1 = typed(block, pt) - val catches1 = typedCases(catches, ThrowableClass.tpe, pt) - val fin1 = if (fin.isEmpty) fin else typed(fin, UnitClass.tpe) + val catches1 = typedCases(catches, ThrowableTpe, pt) + val fin1 = if (fin.isEmpty) fin else typed(fin, UnitTpe) def finish(ownType: Type) = treeCopy.Try(tree, block1, catches1, fin1) setType ownType @@ -5058,8 +5058,8 @@ trait Typers extends Adaptations with Tags { } def typedThrow(tree: Throw) = { - val expr1 = typedByValueExpr(tree.expr, ThrowableClass.tpe) - treeCopy.Throw(tree, expr1) setType NothingClass.tpe + val expr1 = typedByValueExpr(tree.expr, ThrowableTpe) + treeCopy.Throw(tree, expr1) setType NothingTpe } def typedTyped(tree: Typed) = { @@ -5145,7 +5145,7 @@ trait Typers extends Adaptations with Tags { // @M maybe the well-kindedness check should be done when checking the type arguments conform to the type parameters' bounds? val args1 = if (sameLength(args, tparams)) map2Conserve(args, tparams) { //@M! the polytype denotes the expected kind - (arg, tparam) => typedHigherKindedType(arg, mode, GenPolyType(tparam.typeParams, AnyClass.tpe)) + (arg, tparam) => typedHigherKindedType(arg, mode, GenPolyType(tparam.typeParams, AnyTpe)) } else { //@M this branch is correctly hit for an overloaded polymorphic type. It also has to handle erroneous cases. @@ -5163,9 +5163,9 @@ trait Typers extends Adaptations with Tags { def typedApplyDynamic(tree: ApplyDynamic) = { assert(phase.erasedTypes) - val qual1 = typed(tree.qual, AnyRefClass.tpe) - val args1 = tree.args mapConserve (arg => typed(arg, AnyRefClass.tpe)) - treeCopy.ApplyDynamic(tree, qual1, args1) setType AnyRefClass.tpe + val qual1 = typed(tree.qual, AnyRefTpe) + val args1 = tree.args mapConserve (arg => typed(arg, AnyRefTpe)) + treeCopy.ApplyDynamic(tree, qual1, args1) setType AnyRefTpe } def typedReferenceToBoxed(tree: ReferenceToBoxed) = { @@ -5207,14 +5207,14 @@ trait Typers extends Adaptations with Tags { warnMissingInterpolator(tree) tree setType ( - if (tree.value.tag == UnitTag) UnitClass.tpe + if (tree.value.tag == UnitTag) UnitTpe else ConstantType(tree.value)) } def typedSingletonTypeTree(tree: SingletonTypeTree) = { val refTyped = context.withImplicitsDisabled { - typed(tree.ref, MonoQualifierModes | mode.onlyTypePat, AnyRefClass.tpe) + typed(tree.ref, MonoQualifierModes | mode.onlyTypePat, AnyRefTpe) } if (!refTyped.isErrorTyped) @@ -5257,7 +5257,7 @@ trait Typers extends Adaptations with Tags { // we should get here only when something before failed // and we try again (@see tryTypedApply). In that case we can assign // whatever type to tree; we just have to survive until a real error message is issued. - tree setType AnyClass.tpe + tree setType AnyTpe } def typedFunction(fun: Function) = { if (fun.symbol == NoSymbol) @@ -5534,7 +5534,7 @@ trait Typers extends Adaptations with Tags { val isMacroBodyOkay = !tree.symbol.isErroneous && !(tree1 exists (_.isErroneous)) && tree1 != EmptyTree val shouldInheritMacroImplReturnType = ddef.tpt.isEmpty - if (isMacroBodyOkay && shouldInheritMacroImplReturnType) computeMacroDefTypeFromMacroImpl(ddef, tree1.symbol) else AnyClass.tpe + if (isMacroBodyOkay && shouldInheritMacroImplReturnType) computeMacroDefTypeFromMacroImpl(ddef, tree1.symbol) else AnyTpe } def transformedOr(tree: Tree, op: => Tree): Tree = transformed remove tree match { diff --git a/src/compiler/scala/tools/reflect/ToolBoxFactory.scala b/src/compiler/scala/tools/reflect/ToolBoxFactory.scala index 59408096a3..6145e61c4f 100644 --- a/src/compiler/scala/tools/reflect/ToolBoxFactory.scala +++ b/src/compiler/scala/tools/reflect/ToolBoxFactory.scala @@ -129,7 +129,7 @@ abstract class ToolBoxFactory[U <: JavaUniverse](val u: U) { factorySelf => // it inaccessible then please put it somewhere designed for that // rather than polluting the empty package with synthetics. val ownerClass = rootMirror.EmptyPackageClass.newClassSymbol(newTypeName("<expression-owner>")) - build.setTypeSignature(ownerClass, ClassInfoType(List(ObjectClass.tpe), newScope, ownerClass)) + build.setTypeSignature(ownerClass, ClassInfoType(List(ObjectTpe), newScope, ownerClass)) val owner = ownerClass.newLocalDummy(expr.pos) val currentTyper = analyzer.newTyper(analyzer.rootContext(NoCompilationUnit, EmptyTree).make(expr, owner)) val wrapper1 = if (!withImplicitViewsDisabled) (currentTyper.context.withImplicitsEnabled[Tree] _) else (currentTyper.context.withImplicitsDisabled[Tree] _) @@ -196,7 +196,7 @@ abstract class ToolBoxFactory[U <: JavaUniverse](val u: U) { factorySelf => val (obj, _) = rootMirror.EmptyPackageClass.newModuleAndClassSymbol( nextWrapperModuleName()) - val minfo = ClassInfoType(List(ObjectClass.tpe), newScope, obj.moduleClass) + val minfo = ClassInfoType(List(ObjectTpe), newScope, obj.moduleClass) obj.moduleClass setInfo minfo obj setInfo obj.moduleClass.tpe @@ -206,7 +206,7 @@ abstract class ToolBoxFactory[U <: JavaUniverse](val u: U) { factorySelf => val (fv, name) = schema meth.newValueParameter(name, newFlags = if (fv.hasStableFlag) STABLE else 0) setInfo appliedType(definitions.FunctionClass(0).tpe, List(fv.tpe.resultType)) } - meth setInfo MethodType(freeTerms.map(makeParam).toList, AnyClass.tpe) + meth setInfo MethodType(freeTerms.map(makeParam).toList, AnyTpe) minfo.decls enter meth def defOwner(tree: Tree): Symbol = tree find (_.isDef) map (_.symbol) match { case Some(sym) if sym != null && sym != NoSymbol => sym.owner @@ -218,7 +218,7 @@ abstract class ToolBoxFactory[U <: JavaUniverse](val u: U) { factorySelf => val moduledef = ModuleDef( obj, Template( - List(TypeTree(ObjectClass.tpe)), + List(TypeTree(ObjectTpe)), emptyValDef, NoMods, List(), diff --git a/src/continuations/plugin/scala/tools/selectivecps/CPSAnnotationChecker.scala b/src/continuations/plugin/scala/tools/selectivecps/CPSAnnotationChecker.scala index e6153596f7..f260ee4093 100644 --- a/src/continuations/plugin/scala/tools/selectivecps/CPSAnnotationChecker.scala +++ b/src/continuations/plugin/scala/tools/selectivecps/CPSAnnotationChecker.scala @@ -95,7 +95,7 @@ abstract class CPSAnnotationChecker extends CPSUtils { override def adaptBoundsToAnnotations(bounds: List[TypeBounds], tparams: List[Symbol], targs: List[Type]): List[TypeBounds] = { if (!cpsEnabled) return bounds - val anyAtCPS = newCpsParamsMarker(NothingClass.tpe, AnyClass.tpe) + val anyAtCPS = newCpsParamsMarker(NothingTpe, AnyTpe) if (isFunctionType(tparams.head.owner.tpe_*) || isPartialFunctionType(tparams.head.owner.tpe_*)) { vprintln("function bound: " + tparams.head.owner.tpe + "/"+bounds+"/"+targs) if (hasCpsParamTypes(targs.last)) @@ -234,7 +234,7 @@ abstract class CPSAnnotationChecker extends CPSUtils { } /** Returns an adapted type for a return expression if the method's result type (pt) is a CPS type. - * Otherwise, it returns the `default` type (`typedReturn` passes `NothingClass.tpe`). + * Otherwise, it returns the `default` type (`typedReturn` passes `NothingTpe`). * * A return expression in a method that has a CPS result type is an error unless the return * is in tail position. Therefore, we are making sure that only the types of return expressions diff --git a/src/continuations/plugin/scala/tools/selectivecps/SelectiveCPSTransform.scala b/src/continuations/plugin/scala/tools/selectivecps/SelectiveCPSTransform.scala index 846ce01953..908ffb3713 100644 --- a/src/continuations/plugin/scala/tools/selectivecps/SelectiveCPSTransform.scala +++ b/src/continuations/plugin/scala/tools/selectivecps/SelectiveCPSTransform.scala @@ -189,7 +189,7 @@ abstract class SelectiveCPSTransform extends PluginComponent with val targettp = transformCPSType(tree.tpe) val pos = catches.head.pos - val funSym = currentOwner.newValueParameter(cpsNames.catches, pos).setInfo(appliedType(PartialFunctionClass, ThrowableClass.tpe, targettp)) + val funSym = currentOwner.newValueParameter(cpsNames.catches, pos).setInfo(appliedType(PartialFunctionClass, ThrowableTpe, targettp)) val funDef = localTyper.typedPos(pos) { ValDef(funSym, Match(EmptyTree, catches1)) } @@ -197,7 +197,7 @@ abstract class SelectiveCPSTransform extends PluginComponent with Apply(Select(expr1, expr1.tpe.member(cpsNames.flatMapCatch)), List(Ident(funSym))) } - val exSym = currentOwner.newValueParameter(cpsNames.ex, pos).setInfo(ThrowableClass.tpe) + val exSym = currentOwner.newValueParameter(cpsNames.ex, pos).setInfo(ThrowableTpe) import CODE._ // generate a case that is supported directly by the back-end @@ -207,8 +207,8 @@ abstract class SelectiveCPSTransform extends PluginComponent with IF ((REF(funSym) DOT nme.isDefinedAt)(REF(exSym))) THEN (REF(funSym) APPLY (REF(exSym))) ELSE Throw(REF(exSym)) ) - val catch2 = localTyper.typedCases(List(catchIfDefined), ThrowableClass.tpe, targettp) - //typedCases(tree, catches, ThrowableClass.tpe, pt) + val catch2 = localTyper.typedCases(List(catchIfDefined), ThrowableTpe, targettp) + //typedCases(tree, catches, ThrowableTpe, pt) patmatTransformer.transform(localTyper.typed(Block(List(funDef), treeCopy.Try(tree, treeCopy.Block(block1, stms, expr2), catch2, finalizer1)))) diff --git a/src/interactive/scala/tools/nsc/interactive/Global.scala b/src/interactive/scala/tools/nsc/interactive/Global.scala index 6a833ab864..99f2cd4056 100644 --- a/src/interactive/scala/tools/nsc/interactive/Global.scala +++ b/src/interactive/scala/tools/nsc/interactive/Global.scala @@ -1089,7 +1089,7 @@ class Global(settings: Settings, _reporter: Reporter, projectName: String = "") val applicableViews: List[SearchResult] = if (ownerTpe.isErroneous) List() else new ImplicitSearch( - tree, functionType(List(ownerTpe), AnyClass.tpe), isView = true, + tree, functionType(List(ownerTpe), AnyTpe), isView = true, context0 = context.makeImplicit(reportAmbiguousErrors = false)).allImplicits for (view <- applicableViews) { val vtree = viewApply(view) diff --git a/src/reflect/scala/reflect/internal/BaseTypeSeqs.scala b/src/reflect/scala/reflect/internal/BaseTypeSeqs.scala index 66eddd7ec0..368e1cde30 100644 --- a/src/reflect/scala/reflect/internal/BaseTypeSeqs.scala +++ b/src/reflect/scala/reflect/internal/BaseTypeSeqs.scala @@ -181,7 +181,7 @@ trait BaseTypeSeqs { def nextRawElem(i: Int): Type = { val j = index(i) val pbts = pbtss(i) - if (j < pbts.length) pbts.rawElem(j) else AnyClass.tpe + if (j < pbts.length) pbts.rawElem(j) else AnyTpe } var minSym: Symbol = NoSymbol while (minSym != AnyClass) { diff --git a/src/reflect/scala/reflect/internal/Constants.scala b/src/reflect/scala/reflect/internal/Constants.scala index 905c7caa52..aa95db546f 100644 --- a/src/reflect/scala/reflect/internal/Constants.scala +++ b/src/reflect/scala/reflect/internal/Constants.scala @@ -63,17 +63,17 @@ trait Constants extends api.Constants { def isAnyVal = UnitTag <= tag && tag <= DoubleTag def tpe: Type = tag match { - case UnitTag => UnitClass.tpe - case BooleanTag => BooleanClass.tpe - case ByteTag => ByteClass.tpe - case ShortTag => ShortClass.tpe - case CharTag => CharClass.tpe - case IntTag => IntClass.tpe - case LongTag => LongClass.tpe - case FloatTag => FloatClass.tpe - case DoubleTag => DoubleClass.tpe - case StringTag => StringClass.tpe - case NullTag => NullClass.tpe + case UnitTag => UnitTpe + case BooleanTag => BooleanTpe + case ByteTag => ByteTpe + case ShortTag => ShortTpe + case CharTag => CharTpe + case IntTag => IntTpe + case LongTag => LongTpe + case FloatTag => FloatTpe + case DoubleTag => DoubleTpe + case StringTag => StringTpe + case NullTag => NullTpe case ClazzTag => ClassType(typeValue) case EnumTag => EnumType(symbolValue) } diff --git a/src/reflect/scala/reflect/internal/Definitions.scala b/src/reflect/scala/reflect/internal/Definitions.scala index b32d439426..040ea5fa4e 100644 --- a/src/reflect/scala/reflect/internal/Definitions.scala +++ b/src/reflect/scala/reflect/internal/Definitions.scala @@ -127,15 +127,15 @@ trait Definitions extends api.StandardDefinitions { lazy val Boolean_or = getMemberMethod(BooleanClass, nme.ZOR) lazy val Boolean_not = getMemberMethod(BooleanClass, nme.UNARY_!) - lazy val UnitTpe = UnitClass.toTypeConstructor - lazy val ByteTpe = ByteClass.toTypeConstructor - lazy val ShortTpe = ShortClass.toTypeConstructor - lazy val CharTpe = CharClass.toTypeConstructor - lazy val IntTpe = IntClass.toTypeConstructor - lazy val LongTpe = LongClass.toTypeConstructor - lazy val FloatTpe = FloatClass.toTypeConstructor - lazy val DoubleTpe = DoubleClass.toTypeConstructor - lazy val BooleanTpe = BooleanClass.toTypeConstructor + lazy val UnitTpe = UnitClass.tpe + lazy val ByteTpe = ByteClass.tpe + lazy val ShortTpe = ShortClass.tpe + lazy val CharTpe = CharClass.tpe + lazy val IntTpe = IntClass.tpe + lazy val LongTpe = LongClass.tpe + lazy val FloatTpe = FloatClass.tpe + lazy val DoubleTpe = DoubleClass.tpe + lazy val BooleanTpe = BooleanClass.tpe lazy val ScalaNumericValueClasses = ScalaValueClasses filterNot Set[Symbol](UnitClass, BooleanClass) lazy val ScalaValueClassesNoUnit = ScalaValueClasses filterNot (_ eq UnitClass) @@ -178,16 +178,6 @@ trait Definitions extends api.StandardDefinitions { lazy val RuntimePackage = getPackage("scala.runtime") lazy val RuntimePackageClass = RuntimePackage.moduleClass.asClass - // convenient one-argument parameter lists - lazy val anyparam = List(AnyClass.tpe) - lazy val anyvalparam = List(AnyValClass.typeConstructor) - lazy val anyrefparam = List(AnyRefClass.typeConstructor) - - // private parameter conveniences - private def booltype = BooleanClass.tpe - private def inttype = IntClass.tpe - private def stringtype = StringClass.tpe - def javaTypeToValueClass(jtype: Class[_]): Symbol = jtype match { case java.lang.Void.TYPE => UnitClass case java.lang.Byte.TYPE => ByteClass @@ -252,9 +242,9 @@ trait Definitions extends api.StandardDefinitions { /** Is this type equivalent to Any, AnyVal, or AnyRef? */ def isTrivialTopType(tp: Type) = ( - tp =:= AnyClass.tpe - || tp =:= AnyValClass.tpe - || tp =:= AnyRefClass.tpe + tp =:= AnyTpe + || tp =:= AnyValTpe + || tp =:= AnyRefTpe ) private def fixupAsAnyTrait(tpe: Type): Type = tpe match { @@ -262,7 +252,7 @@ trait Definitions extends api.StandardDefinitions { if (parents.head.typeSymbol == AnyClass) tpe else { assert(parents.head.typeSymbol == ObjectClass, parents) - ClassInfoType(AnyClass.tpe :: parents.tail, decls, clazz) + ClassInfoType(AnyTpe :: parents.tail, decls, clazz) } case PolyType(tparams, restpe) => PolyType(tparams, fixupAsAnyTrait(restpe)) @@ -270,11 +260,20 @@ trait Definitions extends api.StandardDefinitions { // top types lazy val AnyClass = enterNewClass(ScalaPackageClass, tpnme.Any, Nil, ABSTRACT) - lazy val AnyRefClass = newAlias(ScalaPackageClass, tpnme.AnyRef, ObjectClass.tpe) + lazy val AnyRefClass = newAlias(ScalaPackageClass, tpnme.AnyRef, ObjectTpe) lazy val ObjectClass = getRequiredClass(sn.Object.toString) - lazy val AnyTpe = definitions.AnyClass.toTypeConstructor - lazy val AnyRefTpe = definitions.AnyRefClass.toTypeConstructor - lazy val ObjectTpe = definitions.ObjectClass.toTypeConstructor + + // Cached types for core monomorphic classes + lazy val AnyRefTpe = AnyRefClass.tpe + lazy val AnyTpe = AnyClass.tpe + lazy val AnyValTpe = AnyValClass.tpe + lazy val BoxedUnitTpe = BoxedUnitClass.tpe + lazy val NothingTpe = NothingClass.tpe + lazy val NullTpe = NullClass.tpe + lazy val ObjectTpe = ObjectClass.tpe + lazy val SerializableTpe = SerializableClass.tpe + lazy val StringTpe = StringClass.tpe + lazy val ThrowableTpe = ThrowableClass.tpe // Note: this is not the type alias AnyRef, it's a companion-like // object used by the @specialize annotation. @@ -283,12 +282,11 @@ trait Definitions extends api.StandardDefinitions { def Predef_AnyRef = AnyRefModule lazy val AnyValClass: ClassSymbol = (ScalaPackageClass.info member tpnme.AnyVal orElse { - val anyval = enterNewClass(ScalaPackageClass, tpnme.AnyVal, AnyClass.tpe :: Nil, ABSTRACT) + val anyval = enterNewClass(ScalaPackageClass, tpnme.AnyVal, AnyTpe :: Nil, ABSTRACT) val av_constr = anyval.newClassConstructor(NoPosition) anyval.info.decls enter av_constr anyval }).asInstanceOf[ClassSymbol] - lazy val AnyValTpe = definitions.AnyValClass.toTypeConstructor def AnyVal_getClass = getMemberMethod(AnyValClass, nme.getClass_) // bottom types @@ -311,8 +309,6 @@ trait Definitions extends api.StandardDefinitions { || (that ne NothingClass) && (that isSubClass ObjectClass) ) } - lazy val NothingTpe = definitions.NothingClass.toTypeConstructor - lazy val NullTpe = definitions.NullClass.toTypeConstructor // exceptions and other throwables lazy val ClassCastExceptionClass = requiredClass[ClassCastException] @@ -393,7 +389,7 @@ trait Definitions extends api.StandardDefinitions { def delayedInitMethod = getMemberMethod(DelayedInitClass, nme.delayedInit) lazy val TypeConstraintClass = requiredClass[scala.annotation.TypeConstraint] - lazy val SingletonClass = enterNewClass(ScalaPackageClass, tpnme.Singleton, anyparam, ABSTRACT | TRAIT | FINAL) + lazy val SingletonClass = enterNewClass(ScalaPackageClass, tpnme.Singleton, AnyTpe :: Nil, ABSTRACT | TRAIT | FINAL) lazy val SerializableClass = requiredClass[scala.Serializable] lazy val JavaSerializableClass = requiredClass[java.io.Serializable] modifyInfo fixupAsAnyTrait lazy val ComparableClass = requiredClass[java.lang.Comparable[_]] modifyInfo fixupAsAnyTrait @@ -403,7 +399,7 @@ trait Definitions extends api.StandardDefinitions { lazy val RemoteInterfaceClass = requiredClass[java.rmi.Remote] lazy val RemoteExceptionClass = requiredClass[java.rmi.RemoteException] - lazy val ByNameParamClass = specialPolyClass(tpnme.BYNAME_PARAM_CLASS_NAME, COVARIANT)(_ => AnyClass.tpe) + lazy val ByNameParamClass = specialPolyClass(tpnme.BYNAME_PARAM_CLASS_NAME, COVARIANT)(_ => AnyTpe) lazy val JavaRepeatedParamClass = specialPolyClass(tpnme.JAVA_REPEATED_PARAM_CLASS_NAME, COVARIANT)(tparam => arrayType(tparam.tpe)) lazy val RepeatedParamClass = specialPolyClass(tpnme.REPEATED_PARAM_CLASS_NAME, COVARIANT)(tparam => seqType(tparam.tpe)) @@ -447,7 +443,7 @@ trait Definitions extends api.StandardDefinitions { } def isReferenceArray(tp: Type) = tp match { - case TypeRef(_, ArrayClass, arg :: Nil) => arg <:< AnyRefClass.tpe + case TypeRef(_, ArrayClass, arg :: Nil) => arg <:< AnyRefTpe case _ => false } def isArrayOfSymbol(tp: Type, elem: Symbol) = tp match { @@ -597,7 +593,7 @@ trait Definitions extends api.StandardDefinitions { case BooleanClass => nme.wrapBooleanArray case UnitClass => nme.wrapUnitArray case _ => - if ((elemtp <:< AnyRefClass.tpe) && !isPhantomClass(elemtp.typeSymbol)) nme.wrapRefArray + if ((elemtp <:< AnyRefTpe) && !isPhantomClass(elemtp.typeSymbol)) nme.wrapRefArray else nme.genericWrapArray } @@ -733,12 +729,12 @@ trait Definitions extends api.StandardDefinitions { existentialAbstraction(clazz.unsafeTypeParams, clazz.tpe_*) // members of class scala.Any - lazy val Any_== = enterNewMethod(AnyClass, nme.EQ, anyparam, booltype, FINAL) - lazy val Any_!= = enterNewMethod(AnyClass, nme.NE, anyparam, booltype, FINAL) - lazy val Any_equals = enterNewMethod(AnyClass, nme.equals_, anyparam, booltype) - lazy val Any_hashCode = enterNewMethod(AnyClass, nme.hashCode_, Nil, inttype) - lazy val Any_toString = enterNewMethod(AnyClass, nme.toString_, Nil, stringtype) - lazy val Any_## = enterNewMethod(AnyClass, nme.HASHHASH, Nil, inttype, FINAL) + lazy val Any_== = enterNewMethod(AnyClass, nme.EQ, AnyTpe :: Nil, BooleanTpe, FINAL) + lazy val Any_!= = enterNewMethod(AnyClass, nme.NE, AnyTpe :: Nil, BooleanTpe, FINAL) + lazy val Any_equals = enterNewMethod(AnyClass, nme.equals_, AnyTpe :: Nil, BooleanTpe) + lazy val Any_hashCode = enterNewMethod(AnyClass, nme.hashCode_, Nil, IntTpe) + lazy val Any_toString = enterNewMethod(AnyClass, nme.toString_, Nil, StringTpe) + lazy val Any_## = enterNewMethod(AnyClass, nme.HASHHASH, Nil, IntTpe, FINAL) // Any_getClass requires special handling. The return type is determined on // a per-call-site basis as if the function being called were actually: @@ -750,7 +746,7 @@ trait Definitions extends api.StandardDefinitions { // participation. At the "Any" level, the return type is Class[_] as it is in // java.lang.Object. Java also special cases the return type. lazy val Any_getClass = enterNewMethod(AnyClass, nme.getClass_, Nil, getMemberMethod(ObjectClass, nme.getClass_).tpe.resultType, DEFERRED) - lazy val Any_isInstanceOf = newT1NullaryMethod(AnyClass, nme.isInstanceOf_, FINAL)(_ => booltype) + lazy val Any_isInstanceOf = newT1NullaryMethod(AnyClass, nme.isInstanceOf_, FINAL)(_ => BooleanTpe) lazy val Any_asInstanceOf = newT1NullaryMethod(AnyClass, nme.asInstanceOf_, FINAL)(_.typeConstructor) // A type function from T => Class[U], used to determine the return @@ -774,7 +770,7 @@ trait Definitions extends api.StandardDefinitions { else { val eparams = typeParamsToExistentials(ClassClass, ClassClass.typeParams) val upperBound = ( - if (isPhantomClass(sym)) AnyClass.tpe + if (isPhantomClass(sym)) AnyTpe else if (sym.isLocalClass) erasure.intersectionDominator(tp.parents) else tp.widen ) @@ -834,17 +830,17 @@ trait Definitions extends api.StandardDefinitions { } // members of class java.lang.{ Object, String } - lazy val Object_## = enterNewMethod(ObjectClass, nme.HASHHASH, Nil, inttype, FINAL) - lazy val Object_== = enterNewMethod(ObjectClass, nme.EQ, anyrefparam, booltype, FINAL) - lazy val Object_!= = enterNewMethod(ObjectClass, nme.NE, anyrefparam, booltype, FINAL) - lazy val Object_eq = enterNewMethod(ObjectClass, nme.eq, anyrefparam, booltype, FINAL) - lazy val Object_ne = enterNewMethod(ObjectClass, nme.ne, anyrefparam, booltype, FINAL) - lazy val Object_isInstanceOf = newT1NoParamsMethod(ObjectClass, nme.isInstanceOf_Ob, FINAL | SYNTHETIC | ARTIFACT)(_ => booltype) + lazy val Object_## = enterNewMethod(ObjectClass, nme.HASHHASH, Nil, IntTpe, FINAL) + lazy val Object_== = enterNewMethod(ObjectClass, nme.EQ, AnyRefTpe :: Nil, BooleanTpe, FINAL) + lazy val Object_!= = enterNewMethod(ObjectClass, nme.NE, AnyRefTpe :: Nil, BooleanTpe, FINAL) + lazy val Object_eq = enterNewMethod(ObjectClass, nme.eq, AnyRefTpe :: Nil, BooleanTpe, FINAL) + lazy val Object_ne = enterNewMethod(ObjectClass, nme.ne, AnyRefTpe :: Nil, BooleanTpe, FINAL) + lazy val Object_isInstanceOf = newT1NoParamsMethod(ObjectClass, nme.isInstanceOf_Ob, FINAL | SYNTHETIC | ARTIFACT)(_ => BooleanTpe) lazy val Object_asInstanceOf = newT1NoParamsMethod(ObjectClass, nme.asInstanceOf_Ob, FINAL | SYNTHETIC | ARTIFACT)(_.typeConstructor) lazy val Object_synchronized = newPolyMethod(1, ObjectClass, nme.synchronized_, FINAL)(tps => (Some(List(tps.head.typeConstructor)), tps.head.typeConstructor) ) - lazy val String_+ = enterNewMethod(StringClass, nme.raw.PLUS, anyparam, stringtype, FINAL) + lazy val String_+ = enterNewMethod(StringClass, nme.raw.PLUS, AnyTpe :: Nil, StringTpe, FINAL) def Object_getClass = getMemberMethod(ObjectClass, nme.getClass_) def Object_clone = getMemberMethod(ObjectClass, nme.clone_) @@ -1044,7 +1040,7 @@ trait Definitions extends api.StandardDefinitions { private def specialPolyClass(name: TypeName, flags: Long)(parentFn: Symbol => Type): ClassSymbol = { val clazz = enterNewClass(ScalaPackageClass, name, Nil) val tparam = clazz.newSyntheticTypeParam("T0", flags) - val parents = List(AnyRefClass.tpe, parentFn(tparam)) + val parents = List(AnyRefTpe, parentFn(tparam)) clazz setInfo GenPolyType(List(tparam), ClassInfoType(parents, newScope, clazz)) } diff --git a/src/reflect/scala/reflect/internal/Symbols.scala b/src/reflect/scala/reflect/internal/Symbols.scala index f8fa5c515b..74ae8b9ee1 100644 --- a/src/reflect/scala/reflect/internal/Symbols.scala +++ b/src/reflect/scala/reflect/internal/Symbols.scala @@ -237,7 +237,7 @@ trait Symbols extends api.Symbols { self: SymbolTable => /** Static constructor with info set. */ def newStaticConstructor(pos: Position): MethodSymbol = - newConstructor(pos, STATIC) setInfo UnitClass.tpe + newConstructor(pos, STATIC) setInfo UnitTpe /** Instance constructor with info set. */ def newClassConstructor(pos: Position): MethodSymbol = @@ -1622,7 +1622,7 @@ trait Symbols extends api.Symbols { self: SymbolTable => def makeSerializable() { info match { case ci @ ClassInfoType(_, _, _) => - setInfo(ci.copy(parents = ci.parents :+ SerializableClass.tpe)) + setInfo(ci.copy(parents = ci.parents :+ SerializableTpe)) case i => abort("Only ClassInfoTypes can be made serializable: "+ i) } diff --git a/src/reflect/scala/reflect/internal/TreeGen.scala b/src/reflect/scala/reflect/internal/TreeGen.scala index 44c66b2bbf..6abf344adb 100644 --- a/src/reflect/scala/reflect/internal/TreeGen.scala +++ b/src/reflect/scala/reflect/internal/TreeGen.scala @@ -227,7 +227,7 @@ abstract class TreeGen extends macros.TreeBuilder { /** Cast `tree` to `pt`, unless tpe is a subtype of pt, or pt is Unit. */ def maybeMkAsInstanceOf(tree: Tree, pt: Type, tpe: Type, beforeRefChecks: Boolean = false): Tree = - if ((pt == UnitClass.tpe) || (tpe <:< pt)) tree + if ((pt == UnitTpe) || (tpe <:< pt)) tree else atPos(tree.pos)(mkAsInstanceOf(tree, pt, any = true, wrapInApply = !beforeRefChecks)) /** Apparently we smuggle a Type around as a Literal(Constant(tp)) @@ -253,7 +253,7 @@ abstract class TreeGen extends macros.TreeBuilder { * which is appropriate to the given Type. */ def mkZero(tp: Type): Tree = tp.typeSymbol match { - case NothingClass => mkMethodCall(Predef_???, Nil) setType NothingClass.tpe + case NothingClass => mkMethodCall(Predef_???, Nil) setType NothingTpe case _ => Literal(mkConstantZero(tp)) setType tp } diff --git a/src/reflect/scala/reflect/internal/Types.scala b/src/reflect/scala/reflect/internal/Types.scala index 6582459afe..09cd5d591f 100644 --- a/src/reflect/scala/reflect/internal/Types.scala +++ b/src/reflect/scala/reflect/internal/Types.scala @@ -395,7 +395,7 @@ trait Types /** For a class with nonEmpty parents, the first parent. * Otherwise some specific fixed top type. */ - def firstParent = if (parents.nonEmpty) parents.head else ObjectClass.tpe + def firstParent = if (parents.nonEmpty) parents.head else ObjectTpe /** For a typeref or single-type, the prefix of the normalized type (@see normalize). * NoType for all other types. */ @@ -1462,9 +1462,9 @@ trait Types final class UniqueTypeBounds(lo: Type, hi: Type) extends TypeBounds(lo, hi) object TypeBounds extends TypeBoundsExtractor { - def empty: TypeBounds = apply(NothingClass.tpe, AnyClass.tpe) - def upper(hi: Type): TypeBounds = apply(NothingClass.tpe, hi) - def lower(lo: Type): TypeBounds = apply(lo, AnyClass.tpe) + def empty: TypeBounds = apply(NothingTpe, AnyTpe) + def upper(hi: Type): TypeBounds = apply(NothingTpe, hi) + def lower(lo: Type): TypeBounds = apply(lo, AnyTpe) def apply(lo: Type, hi: Type): TypeBounds = { unique(new UniqueTypeBounds(lo, hi)).asInstanceOf[TypeBounds] } @@ -2472,7 +2472,7 @@ trait Types if (!isValidForBaseClasses(period)) { tpe.parentsCache = tpe.thisInfo.parents map tpe.transform } else if (tpe.parentsCache == null) { // seems this can happen if things are corrupted enough, see #2641 - tpe.parentsCache = List(AnyClass.tpe) + tpe.parentsCache = List(AnyTpe) } } } @@ -3443,7 +3443,7 @@ trait Types /** the canonical creator for a refined type with a given scope */ def refinedType(parents: List[Type], owner: Symbol, decls: Scope, pos: Position): Type = { if (phase.erasedTypes) - if (parents.isEmpty) ObjectClass.tpe else parents.head + if (parents.isEmpty) ObjectTpe else parents.head else { val clazz = owner.newRefinementClass(pos) val result = RefinedType(parents, decls, clazz) @@ -4345,7 +4345,7 @@ trait Types } else { val args = argss map (_.head) if (args.tail forall (_ =:= args.head)) Some(typeRef(pre, sym, List(args.head))) - else if (args exists (arg => isPrimitiveValueClass(arg.typeSymbol))) Some(ObjectClass.tpe) + else if (args exists (arg => isPrimitiveValueClass(arg.typeSymbol))) Some(ObjectTpe) else Some(typeRef(pre, sym, List(lub(args)))) } } @@ -4484,18 +4484,18 @@ trait Types } def isUnboundedGeneric(tp: Type) = tp match { - case t @ TypeRef(_, sym, _) => sym.isAbstractType && !(t <:< AnyRefClass.tpe) + case t @ TypeRef(_, sym, _) => sym.isAbstractType && !(t <:< AnyRefTpe) case _ => false } def isBoundedGeneric(tp: Type) = tp match { - case TypeRef(_, sym, _) if sym.isAbstractType => (tp <:< AnyRefClass.tpe) + case TypeRef(_, sym, _) if sym.isAbstractType => (tp <:< AnyRefTpe) case TypeRef(_, sym, _) => !isPrimitiveValueClass(sym) case _ => false } // Add serializable to a list of parents, unless one of them already is def addSerializable(ps: Type*): List[Type] = ( if (ps exists typeIsSubTypeOfSerializable) ps.toList - else (ps :+ SerializableClass.tpe).toList + else (ps :+ SerializableTpe).toList ) /** Members of the given class, other than those inherited @@ -4508,7 +4508,7 @@ trait Types def importableMembers(pre: Type): Scope = pre.members filter isImportable def objToAny(tp: Type): Type = - if (!phase.erasedTypes && tp.typeSymbol == ObjectClass) AnyClass.tpe + if (!phase.erasedTypes && tp.typeSymbol == ObjectClass) AnyTpe else tp val shorthands = Set( @@ -4532,7 +4532,7 @@ trait Types private[scala] val typeHasAnnotations = (tp: Type) => tp.annotations.nonEmpty private[scala] val boundsContainType = (bounds: TypeBounds, tp: Type) => bounds containsType tp private[scala] val typeListIsEmpty = (ts: List[Type]) => ts.isEmpty - private[scala] val typeIsSubTypeOfSerializable = (tp: Type) => tp <:< SerializableClass.tpe + private[scala] val typeIsSubTypeOfSerializable = (tp: Type) => tp <:< SerializableTpe private[scala] val typeIsNothing = (tp: Type) => tp.typeSymbolDirect eq NothingClass private[scala] val typeIsAny = (tp: Type) => tp.typeSymbolDirect eq AnyClass private[scala] val typeIsHigherKinded = (tp: Type) => tp.isHigherKinded diff --git a/src/reflect/scala/reflect/internal/tpe/GlbLubs.scala b/src/reflect/scala/reflect/internal/tpe/GlbLubs.scala index 2da9960c81..0a7a2a127c 100644 --- a/src/reflect/scala/reflect/internal/tpe/GlbLubs.scala +++ b/src/reflect/scala/reflect/internal/tpe/GlbLubs.scala @@ -236,7 +236,7 @@ private[internal] trait GlbLubs { */ def weakLub(tps: List[Type]): Type = ( if (tps.isEmpty) - NothingClass.tpe + NothingTpe else if (tps forall isNumericValueType) numericLub(tps) else if (tps exists typeHasAnnotations) @@ -249,7 +249,7 @@ private[internal] trait GlbLubs { ts reduceLeft ((t1, t2) => if (isNumericSubType(t1, t2)) t2 else if (isNumericSubType(t2, t1)) t1 - else IntClass.tpe) + else IntTpe) private val lubResults = new mutable.HashMap[(Int, List[Type]), Type] private val glbResults = new mutable.HashMap[(Int, List[Type]), Type] @@ -272,7 +272,7 @@ private[internal] trait GlbLubs { } def lub(ts: List[Type]): Type = ts match { - case Nil => NothingClass.tpe + case Nil => NothingTpe case t :: Nil => t case _ => if (Statistics.canEnable) Statistics.incCounter(lubCount) @@ -301,7 +301,7 @@ private[internal] trait GlbLubs { /** The least upper bound wrt <:< of a list of types */ protected[internal] def lub(ts: List[Type], depth: Int): Type = { def lub0(ts0: List[Type]): Type = elimSub(ts0, depth) match { - case List() => NothingClass.tpe + case List() => NothingTpe case List(t) => t case ts @ PolyType(tparams, _) :: _ => val tparams1 = map2(tparams, matchingBounds(ts, tparams).transpose)((tparam, bounds) => @@ -320,8 +320,8 @@ private[internal] trait GlbLubs { case Some(lubType) => lubType case None => - lubResults((depth, ts)) = AnyClass.tpe - val res = if (depth < 0) AnyClass.tpe else lub1(ts) + lubResults((depth, ts)) = AnyTpe + val res = if (depth < 0) AnyTpe else lub1(ts) lubResults((depth, ts)) = res res } @@ -437,7 +437,7 @@ private[internal] trait GlbLubs { /** The greatest lower bound of a list of types (as determined by `<:<`). */ def glb(ts: List[Type]): Type = elimSuper(ts) match { - case List() => AnyClass.tpe + case List() => AnyTpe case List(t) => t case ts0 => if (Statistics.canEnable) Statistics.incCounter(lubCount) @@ -452,7 +452,7 @@ private[internal] trait GlbLubs { } protected[internal] def glb(ts: List[Type], depth: Int): Type = elimSuper(ts) match { - case List() => AnyClass.tpe + case List() => AnyTpe case List(t) => t case ts0 => glbNorm(ts0, depth) } @@ -461,7 +461,7 @@ private[internal] trait GlbLubs { * with regard to `elimSuper`. */ protected def glbNorm(ts: List[Type], depth: Int): Type = { def glb0(ts0: List[Type]): Type = ts0 match { - case List() => AnyClass.tpe + case List() => AnyTpe case List(t) => t case ts @ PolyType(tparams, _) :: _ => val tparams1 = map2(tparams, matchingBounds(ts, tparams).transpose)((tparam, bounds) => @@ -478,8 +478,8 @@ private[internal] trait GlbLubs { case Some(glbType) => glbType case _ => - glbResults((depth, ts)) = NothingClass.tpe - val res = if (depth < 0) NothingClass.tpe else glb1(ts) + glbResults((depth, ts)) = NothingTpe + val res = if (depth < 0) NothingTpe else glb1(ts) glbResults((depth, ts)) = res res } @@ -556,8 +556,8 @@ private[internal] trait GlbLubs { existentialAbstraction(tparams, glbType) } catch { case GlbFailure => - if (ts forall (t => NullClass.tpe <:< t)) NullClass.tpe - else NothingClass.tpe + if (ts forall (t => NullTpe <:< t)) NullTpe + else NothingTpe } } // if (settings.debug.value) { println(indent + "glb of " + ts + " at depth "+depth); indent = indent + " " } //DEBUG diff --git a/src/reflect/scala/reflect/internal/tpe/TypeConstraints.scala b/src/reflect/scala/reflect/internal/tpe/TypeConstraints.scala index 39e427f588..123c296f95 100644 --- a/src/reflect/scala/reflect/internal/tpe/TypeConstraints.scala +++ b/src/reflect/scala/reflect/internal/tpe/TypeConstraints.scala @@ -88,8 +88,8 @@ private[internal] trait TypeConstraints { /** @PP: Unable to see why these apparently constant types should need vals * in every TypeConstraint, I lifted them out. */ - private lazy val numericLoBound = IntClass.tpe - private lazy val numericHiBound = intersectionType(List(ByteClass.tpe, CharClass.tpe), ScalaPackageClass) + private lazy val numericLoBound = IntTpe + private lazy val numericHiBound = intersectionType(List(ByteTpe, CharTpe), ScalaPackageClass) /** A class expressing upper and lower bounds constraints of type variables, * as well as their instantiations. diff --git a/src/reflect/scala/reflect/internal/tpe/TypeMaps.scala b/src/reflect/scala/reflect/internal/tpe/TypeMaps.scala index 7665e7c0f4..c35825dcee 100644 --- a/src/reflect/scala/reflect/internal/tpe/TypeMaps.scala +++ b/src/reflect/scala/reflect/internal/tpe/TypeMaps.scala @@ -30,10 +30,10 @@ private[internal] trait TypeMaps { def apply(tp: Type): Type = { tp match { case TypeRef(_, SingletonClass, _) => - AnyClass.tpe + AnyTpe case tp1 @ RefinedType(parents, decls) => parents filter (_.typeSymbol != SingletonClass) match { - case Nil => AnyClass.tpe + case Nil => AnyTpe case p :: Nil if decls.isEmpty => mapOver(p) case ps => mapOver(copyRefinedType(tp1, ps, decls)) } @@ -327,7 +327,7 @@ private[internal] trait TypeMaps { private var expanded = immutable.Set[Symbol]() def apply(tp: Type): Type = tp match { case TypeRef(pre, sym, List()) if isRawIfWithoutArgs(sym) => - if (expanded contains sym) AnyRefClass.tpe + if (expanded contains sym) AnyRefTpe else try { expanded += sym val eparams = mapOver(typeParamsToExistentials(sym)) diff --git a/src/reflect/scala/reflect/internal/transform/Erasure.scala b/src/reflect/scala/reflect/internal/transform/Erasure.scala index 24da8d20cc..a9a1285de3 100644 --- a/src/reflect/scala/reflect/internal/transform/Erasure.scala +++ b/src/reflect/scala/reflect/internal/transform/Erasure.scala @@ -56,7 +56,7 @@ trait Erasure { } protected def unboundedGenericArrayLevel(tp: Type): Int = tp match { - case GenericArray(level, core) if !(core <:< AnyRefClass.tpe) => level + case GenericArray(level, core) if !(core <:< AnyRefTpe) => level case _ => 0 } @@ -106,9 +106,6 @@ trait Erasure { } abstract class ErasureMap extends TypeMap { - private lazy val ObjectArray = arrayType(ObjectClass.tpe) - private lazy val ErasedObject = erasedTypeRef(ObjectClass) - def mergeParents(parents: List[Type]): Type def eraseNormalClassRef(pre: Type, clazz: Symbol): Type = @@ -123,11 +120,11 @@ trait Erasure { apply(st.supertype) case tref @ TypeRef(pre, sym, args) => if (sym == ArrayClass) - if (unboundedGenericArrayLevel(tp) == 1) ObjectClass.tpe - else if (args.head.typeSymbol.isBottomClass) ObjectArray + if (unboundedGenericArrayLevel(tp) == 1) ObjectTpe + else if (args.head.typeSymbol.isBottomClass) arrayType(ObjectTpe) else typeRef(apply(pre), sym, args map applyInArray) - else if (sym == AnyClass || sym == AnyValClass || sym == SingletonClass) ErasedObject - else if (sym == UnitClass) erasedTypeRef(BoxedUnitClass) + else if (sym == AnyClass || sym == AnyValClass || sym == SingletonClass) ObjectTpe + else if (sym == UnitClass) BoxedUnitTpe else if (sym.isRefinementClass) apply(mergeParents(tp.parents)) else if (sym.isDerivedValueClass) eraseDerivedValueClassRef(tref) else if (sym.isClass) eraseNormalClassRef(pre, sym) @@ -139,7 +136,7 @@ trait Erasure { case mt @ MethodType(params, restpe) => MethodType( cloneSymbolsAndModify(params, ErasureMap.this), - if (restpe.typeSymbol == UnitClass) erasedTypeRef(UnitClass) + if (restpe.typeSymbol == UnitClass) UnitTpe // this replaces each typeref that refers to an argument // by the type `p.tpe` of the actual argument p (p in params) else apply(mt.resultType(mt.paramTypes))) @@ -150,7 +147,7 @@ trait Erasure { case ClassInfoType(parents, decls, clazz) => ClassInfoType( if (clazz == ObjectClass || isPrimitiveValueClass(clazz)) Nil - else if (clazz == ArrayClass) List(ErasedObject) + else if (clazz == ArrayClass) ObjectTpe :: Nil else removeLaterObjects(parents map this), decls, clazz) case _ => @@ -253,7 +250,7 @@ trait Erasure { * An intersection such as `Object with Trait` erases to Object. */ def mergeParents(parents: List[Type]): Type = - if (parents.isEmpty) ObjectClass.tpe + if (parents.isEmpty) ObjectTpe else parents.head } @@ -301,7 +298,7 @@ trait Erasure { * - Otherwise, the dominator is the first element of the span. */ def intersectionDominator(parents: List[Type]): Type = { - if (parents.isEmpty) ObjectClass.tpe + if (parents.isEmpty) ObjectTpe else { val psyms = parents map (_.typeSymbol) if (psyms contains ArrayClass) { @@ -323,10 +320,6 @@ trait Erasure { } } - /** Type reference after erasure */ - def erasedTypeRef(sym: Symbol): Type = - typeRef(erasure(sym)(sym.owner.tpe), sym, Nil) - /** The symbol's erased info. This is the type's erasure, except for the following symbols: * * - For $asInstanceOf : [T]T @@ -354,8 +347,7 @@ trait Erasure { else if (sym.name == nme.update) (tp: @unchecked) match { case MethodType(List(index, tvar), restpe) => - MethodType(List(index.cloneSymbol.setInfo(specialErasure(sym)(index.tpe)), tvar), - erasedTypeRef(UnitClass)) + MethodType(List(index.cloneSymbol.setInfo(specialErasure(sym)(index.tpe)), tvar), UnitTpe) } else specialErasure(sym)(tp) } else if ( diff --git a/src/reflect/scala/reflect/internal/transform/UnCurry.scala b/src/reflect/scala/reflect/internal/transform/UnCurry.scala index c525e794a9..abea8bed9f 100644 --- a/src/reflect/scala/reflect/internal/transform/UnCurry.scala +++ b/src/reflect/scala/reflect/internal/transform/UnCurry.scala @@ -46,7 +46,7 @@ trait UnCurry { apply(seqType(arg)) case TypeRef(pre, JavaRepeatedParamClass, arg :: Nil) => apply(arrayType( - if (isUnboundedGeneric(arg)) ObjectClass.tpe else arg)) + if (isUnboundedGeneric(arg)) ObjectTpe else arg)) case _ => expandAlias(mapOver(tp)) } diff --git a/src/reflect/scala/reflect/runtime/JavaMirrors.scala b/src/reflect/scala/reflect/runtime/JavaMirrors.scala index ca9cc85ab2..adee155db0 100644 --- a/src/reflect/scala/reflect/runtime/JavaMirrors.scala +++ b/src/reflect/scala/reflect/runtime/JavaMirrors.scala @@ -701,7 +701,7 @@ private[reflect] trait JavaMirrors extends internal.SymbolTable with api.JavaUni val parents = try { parentsLevel += 1 val jsuperclazz = jclazz.getGenericSuperclass - val superclazz = if (jsuperclazz == null) AnyClass.tpe else typeToScala(jsuperclazz) + val superclazz = if (jsuperclazz == null) AnyTpe else typeToScala(jsuperclazz) superclazz :: (jclazz.getGenericInterfaces.toList map typeToScala) } finally { parentsLevel -= 1 diff --git a/src/repl/scala/tools/nsc/interpreter/JLineCompletion.scala b/src/repl/scala/tools/nsc/interpreter/JLineCompletion.scala index 19fa562234..8b8b668c9f 100644 --- a/src/repl/scala/tools/nsc/interpreter/JLineCompletion.scala +++ b/src/repl/scala/tools/nsc/interpreter/JLineCompletion.scala @@ -15,7 +15,7 @@ import scala.reflect.internal.util.StringOps.longestCommonPrefix class JLineCompletion(val intp: IMain) extends Completion with CompletionOutput { val global: intp.global.type = intp.global import global._ - import definitions.{ PredefModule, AnyClass, AnyRefClass, ScalaPackage, JavaLangPackage } + import definitions._ import rootMirror.{ RootClass, getModuleIfDefined } type ExecResult = Any import intp.{ debugging } @@ -39,7 +39,7 @@ class JLineCompletion(val intp: IMain) extends Completion with CompletionOutput // for some reason any's members don't show up in subclasses, which // we need so 5.<tab> offers asInstanceOf etc. - private def anyMembers = AnyClass.tpe.nonPrivateMembers + private def anyMembers = AnyTpe.nonPrivateMembers def anyRefMethodsToShow = Set("isInstanceOf", "asInstanceOf", "toString") def tos(sym: Symbol): String = sym.decodedName @@ -152,7 +152,7 @@ class JLineCompletion(val intp: IMain) extends Completion with CompletionOutput } // not for completion but for excluding - object anyref extends TypeMemberCompletion(AnyRefClass.tpe) { } + object anyref extends TypeMemberCompletion(AnyRefTpe) { } // the unqualified vals/defs/etc visible in the repl object ids extends CompletionAware { diff --git a/src/scaladoc/scala/tools/nsc/doc/model/ModelFactoryImplicitSupport.scala b/src/scaladoc/scala/tools/nsc/doc/model/ModelFactoryImplicitSupport.scala index d7b324f1d5..f984b4579f 100644 --- a/src/scaladoc/scala/tools/nsc/doc/model/ModelFactoryImplicitSupport.scala +++ b/src/scaladoc/scala/tools/nsc/doc/model/ModelFactoryImplicitSupport.scala @@ -285,7 +285,7 @@ trait ModelFactoryImplicitSupport { (tparams zip constrs) flatMap { case (tparam, constr) => { uniteConstraints(constr) match { - case (loBounds, upBounds) => (loBounds filter (_ != NothingClass.tpe), upBounds filter (_ != AnyClass.tpe)) match { + case (loBounds, upBounds) => (loBounds filter (_ != NothingTpe), upBounds filter (_ != AnyTpe)) match { case (Nil, Nil) => Nil case (List(lo), List(up)) if (lo == up) => @@ -532,7 +532,7 @@ trait ModelFactoryImplicitSupport { object wildcardToNothing extends TypeMap { def apply(tp: Type): Type = mapOver(tp) match { case WildcardType => - NothingClass.tpe + NothingTpe case other => other } |