From 18ae13dcf4f5d40d528e2bcf43a19e84bf475084 Mon Sep 17 00:00:00 2001 From: Martin Odersky Date: Mon, 10 Feb 2014 11:10:20 +0100 Subject: Make Definitions load all symbols in current runId. --- src/dotty/tools/dotc/core/Definitions.scala | 1335 ++------------------------- 1 file changed, 56 insertions(+), 1279 deletions(-) (limited to 'src/dotty/tools/dotc/core/Definitions.scala') diff --git a/src/dotty/tools/dotc/core/Definitions.scala b/src/dotty/tools/dotc/core/Definitions.scala index 801e2cef6..506b46540 100644 --- a/src/dotty/tools/dotc/core/Definitions.scala +++ b/src/dotty/tools/dotc/core/Definitions.scala @@ -16,10 +16,10 @@ object Definitions { } /** A class defining symbols and types of standard definitions */ -class Definitions(implicit ctx: Context) { +class Definitions { import Definitions._ - import ctx.{requiredClass, requiredModule, requiredPackage} + private implicit var ctx: Context = _ private def newSymbol[N <: Name](owner: Symbol, name: N, flags: FlagSet, info: Type) = ctx.newSymbol(owner, name, flags | Permanent, info) @@ -78,7 +78,7 @@ class Definitions(implicit ctx: Context) { private def mkArityArray(name: String, arity: Int, countFrom: Int): Array[ClassSymbol] = { val arr = new Array[ClassSymbol](arity) - for (i <- countFrom until arity) arr(i) = requiredClass("scala." + name + i) + for (i <- countFrom until arity) arr(i) = ctx.requiredClass("scala." + name + i) arr } @@ -90,12 +90,12 @@ class Definitions(implicit ctx: Context) { lazy val EmptyPackageClass = ctx.newCompletePackageSymbol(RootClass, nme.EMPTY_PACKAGE).moduleClass.asClass lazy val EmptyPackageVal = EmptyPackageClass.sourceModule.entered - lazy val ScalaPackageVal = requiredPackage("scala") + lazy val ScalaPackageVal = ctx.requiredPackage("scala") lazy val ScalaPackageClass = ScalaPackageVal.moduleClass.asClass - lazy val JavaPackageVal = requiredPackage("java") - lazy val JavaLangPackageVal = requiredPackage("java.lang") + lazy val JavaPackageVal = ctx.requiredPackage("java") + lazy val JavaLangPackageVal = ctx.requiredPackage("java.lang") - lazy val ObjectClass = requiredClass("java.lang.Object") + lazy val ObjectClass = ctx.requiredClass("java.lang.Object") lazy val AnyRefAlias: TypeSymbol = newAliasType(tpnme.AnyRef, ObjectType) lazy val Object_## = newMethod(ObjectClass, nme.HASHHASH, ExprType(IntType), Final) @@ -124,7 +124,7 @@ class Definitions(implicit ctx: Context) { cls } - lazy val AnyValClass: ClassSymbol = requiredClass("scala.AnyVal") + lazy val AnyValClass: ClassSymbol = ctx.requiredClass("scala.AnyVal") lazy val Any_== = newMethod(AnyClass, nme.EQ, methOfAny(BooleanType), Final) lazy val Any_!= = newMethod(AnyClass, nme.NE, methOfAny(BooleanType), Final) @@ -146,27 +146,27 @@ class Definitions(implicit ctx: Context) { lazy val Any_isInstanceOf = newT1ParameterlessMethod(AnyClass, nme.isInstanceOf_, _ => BooleanType, Final) lazy val Any_asInstanceOf = newT1ParameterlessMethod(AnyClass, nme.asInstanceOf_, PolyParam(_, 0), Final) - lazy val NotNullClass = requiredClass("scala.NotNull") + lazy val NotNullClass = ctx.requiredClass("scala.NotNull") lazy val NothingClass: ClassSymbol = newCompleteClassSymbol( ScalaPackageClass, tpnme.Nothing, AbstractFinal, List(AnyClass.typeRef)) lazy val NullClass: ClassSymbol = newCompleteClassSymbol( ScalaPackageClass, tpnme.Null, AbstractFinal, List(ObjectClass.typeRef)) - lazy val ScalaPredefModule = requiredModule("scala.Predef") - lazy val DottyPredefModule = requiredModule("dotty.DottyPredef") - lazy val NilModule = requiredModule("scala.collection.immutable.Nil") + lazy val ScalaPredefModule = ctx.requiredModule("scala.Predef") + lazy val DottyPredefModule = ctx.requiredModule("dotty.DottyPredef") + lazy val NilModule = ctx.requiredModule("scala.collection.immutable.Nil") -// lazy val FunctionClass: ClassSymbol = requiredClass("scala.Function") +// lazy val FunctionClass: ClassSymbol = ctx.requiredClass("scala.Function") lazy val SingletonClass: ClassSymbol = // needed as a synthetic class because Scala 2.x refers to it in classfiles // but does not define it as an explicit class. newCompleteClassSymbol( ScalaPackageClass, tpnme.Singleton, Trait | Interface | Final, List(AnyClass.typeRef), EmptyScope) - lazy val SeqClass: ClassSymbol = requiredClass("scala.collection.Seq") - lazy val ArrayClass: ClassSymbol = requiredClass("scala.Array") - lazy val uncheckedStableClass: ClassSymbol = requiredClass("scala.annotation.unchecked.uncheckedStable") + lazy val SeqClass: ClassSymbol = ctx.requiredClass("scala.collection.Seq") + lazy val ArrayClass: ClassSymbol = ctx.requiredClass("scala.Array") + lazy val uncheckedStableClass: ClassSymbol = ctx.requiredClass("scala.annotation.unchecked.uncheckedStable") lazy val UnitClass = valueClassSymbol("scala.Unit", BoxedUnitClass, java.lang.Void.TYPE, UnitEnc) lazy val BooleanClass = valueClassSymbol("scala.Boolean", BoxedBooleanClass, java.lang.Boolean.TYPE, BooleanEnc) @@ -178,15 +178,15 @@ class Definitions(implicit ctx: Context) { lazy val FloatClass = valueClassSymbol("scala.Float", BoxedFloatClass, java.lang.Float.TYPE, FloatEnc) lazy val DoubleClass = valueClassSymbol("scala.Double", BoxedDoubleClass, java.lang.Double.TYPE, DoubleEnc) - lazy val BoxedUnitClass = requiredClass("scala.runtime.BoxedUnit") - lazy val BoxedBooleanClass = requiredClass("java.lang.Boolean") - lazy val BoxedByteClass = requiredClass("java.lang.Byte") - lazy val BoxedShortClass = requiredClass("java.lang.Short") - lazy val BoxedCharClass = requiredClass("java.lang.Character") - lazy val BoxedIntClass = requiredClass("java.lang.Integer") - lazy val BoxedLongClass = requiredClass("java.lang.Long") - lazy val BoxedFloatClass = requiredClass("java.lang.Float") - lazy val BoxedDoubleClass = requiredClass("java.lang.Double") + lazy val BoxedUnitClass = ctx.requiredClass("scala.runtime.BoxedUnit") + lazy val BoxedBooleanClass = ctx.requiredClass("java.lang.Boolean") + lazy val BoxedByteClass = ctx.requiredClass("java.lang.Byte") + lazy val BoxedShortClass = ctx.requiredClass("java.lang.Short") + lazy val BoxedCharClass = ctx.requiredClass("java.lang.Character") + lazy val BoxedIntClass = ctx.requiredClass("java.lang.Integer") + lazy val BoxedLongClass = ctx.requiredClass("java.lang.Long") + lazy val BoxedFloatClass = ctx.requiredClass("java.lang.Float") + lazy val BoxedDoubleClass = ctx.requiredClass("java.lang.Double") lazy val ByNameParamClass2x = specialPolyClass(tpnme.BYNAME_PARAM_CLASS, Covariant, AnyType) lazy val EqualsPatternClass = specialPolyClass(tpnme.EQUALS_PATTERN, EmptyFlags, AnyType) @@ -195,45 +195,44 @@ class Definitions(implicit ctx: Context) { lazy val JavaRepeatedParamClass = specialPolyClass(tpnme.JAVA_REPEATED_PARAM_CLASS, Covariant, ArrayType) // fundamental classes - lazy val StringClass = requiredClass("java.lang.String") + lazy val StringClass = ctx.requiredClass("java.lang.String") lazy val String_+ = newMethod(StringClass, nme.raw.PLUS, methOfAny(StringType), Final) - lazy val StringAddClass = requiredClass("scala.runtime.StringAdd") + lazy val StringAddClass = ctx.requiredClass("scala.runtime.StringAdd") lazy val StringAdd_+ = StringAddClass.requiredMethod(nme.raw.PLUS) - lazy val PairClass = requiredClass("dotty.Pair") - lazy val PartialFunctionClass = requiredClass("scala.PartialFunction") - lazy val AbstractPartialFunctionClass = requiredClass("scala.runtime.AbstractPartialFunction") - lazy val SymbolClass = requiredClass("scala.Symbol") - lazy val ClassClass = requiredClass("java.lang.Class") - //def Class_getMethod = requiredMethod(ClassClass, nme.getMethod_) - lazy val DynamicClass = requiredClass("scala.Dynamic") - lazy val OptionClass = requiredClass("scala.Option") - lazy val BoxedNumberClass = requiredClass("java.lang.Number") - lazy val ThrowableClass = requiredClass("java.lang.Throwable") - lazy val JavaSerializableClass = requiredClass("java.lang.Serializable") - lazy val ComparableClass = requiredClass("java.lang.Comparable") - lazy val ProductClass = requiredClass("scala.Product") + lazy val PairClass = ctx.requiredClass("dotty.Pair") + lazy val PartialFunctionClass = ctx.requiredClass("scala.PartialFunction") + lazy val AbstractPartialFunctionClass = ctx.requiredClass("scala.runtime.AbstractPartialFunction") + lazy val SymbolClass = ctx.requiredClass("scala.Symbol") + lazy val ClassClass = ctx.requiredClass("java.lang.Class") + lazy val DynamicClass = ctx.requiredClass("scala.Dynamic") + lazy val OptionClass = ctx.requiredClass("scala.Option") + lazy val BoxedNumberClass = ctx.requiredClass("java.lang.Number") + lazy val ThrowableClass = ctx.requiredClass("java.lang.Throwable") + lazy val JavaSerializableClass = ctx.requiredClass("java.lang.Serializable") + lazy val ComparableClass = ctx.requiredClass("java.lang.Comparable") + lazy val ProductClass = ctx.requiredClass("scala.Product") // Annotation base classes - lazy val AnnotationClass = requiredClass("scala.annotation.Annotation") - lazy val ClassfileAnnotationClass = requiredClass("scala.annotation.ClassfileAnnotation") - lazy val StaticAnnotationClass = requiredClass("scala.annotation.StaticAnnotation") + lazy val AnnotationClass = ctx.requiredClass("scala.annotation.Annotation") + lazy val ClassfileAnnotationClass = ctx.requiredClass("scala.annotation.ClassfileAnnotation") + lazy val StaticAnnotationClass = ctx.requiredClass("scala.annotation.StaticAnnotation") // Annotation classes - lazy val AliasAnnot = requiredClass("dotty.annotation.internal.Alias") - lazy val ChildAnnot = requiredClass("dotty.annotation.internal.Child") - lazy val InvariantBetweenClass = requiredClass("dotty.annotation.internal.InvariantBetween") - lazy val CovariantBetweenClass = requiredClass("dotty.annotation.internal.CovariantBetween") - lazy val ContravariantBetweenClass = requiredClass("dotty.annotation.internal.ContravariantBetween") - lazy val ScalaSignatureAnnot = requiredClass("scala.reflect.ScalaSignature") - lazy val ScalaLongSignatureAnnot = requiredClass("scala.reflect.ScalaLongSignature") - lazy val DeprecatedAnnot = requiredClass("scala.deprecated") - lazy val AnnotationDefaultAnnot = requiredClass("dotty.annotation.internal.AnnotationDefault") - lazy val ThrowsAnnot = requiredClass("scala.throws") - lazy val UncheckedAnnot = requiredClass("scala.unchecked") + lazy val AliasAnnot = ctx.requiredClass("dotty.annotation.internal.Alias") + lazy val ChildAnnot = ctx.requiredClass("dotty.annotation.internal.Child") + lazy val InvariantBetweenClass = ctx.requiredClass("dotty.annotation.internal.InvariantBetween") + lazy val CovariantBetweenClass = ctx.requiredClass("dotty.annotation.internal.CovariantBetween") + lazy val ContravariantBetweenClass = ctx.requiredClass("dotty.annotation.internal.ContravariantBetween") + lazy val ScalaSignatureAnnot = ctx.requiredClass("scala.reflect.ScalaSignature") + lazy val ScalaLongSignatureAnnot = ctx.requiredClass("scala.reflect.ScalaLongSignature") + lazy val DeprecatedAnnot = ctx.requiredClass("scala.deprecated") + lazy val AnnotationDefaultAnnot = ctx.requiredClass("dotty.annotation.internal.AnnotationDefault") + lazy val ThrowsAnnot = ctx.requiredClass("scala.throws") + lazy val UncheckedAnnot = ctx.requiredClass("scala.unchecked") // convenient one-parameter method types def methOfAny(tp: Type) = MethodType(List(AnyType), tp) @@ -421,7 +420,7 @@ class Definitions(implicit ctx: Context) { val valueClassEnc: collection.Map[Symbol, Int] = _valueClassEnc private def valueClassSymbol(name: String, boxed: ClassSymbol, jtype: Class[_], enc: Int): ClassSymbol = { - val vcls = requiredClass(name) + val vcls = ctx.requiredClass(name) _unboxedClass(boxed) = vcls _boxedClass(vcls) = boxed _javaTypeToValueClass(jtype) = vcls @@ -491,1234 +490,12 @@ class Definitions(implicit ctx: Context) { private[this] var _isInitialized = false def isInitialized = _isInitialized - def init() = + def init(implicit ctx: Context) = { + this.ctx = ctx if (!_isInitialized) { // force initialization of every symbol that is synthesized or hijacked by the compiler val forced = syntheticCoreClasses ++ syntheticCoreMethods ++ ScalaValueClasses _isInitialized = true } -} -/* - import rootMirror.{getModule, getClassByName, getRequiredClass, getRequiredModule, getRequiredPackage, getClassIfDefined, getModuleIfDefined, getPackageObject, getPackageObjectIfDefined, requiredClass, requiredModule} - - object definitions extends DefinitionsClass - - /** Since both the value parameter types and the result type may - * require access to the type parameter symbols, we model polymorphic - * creation as a function from those symbols to (formal types, result type). - * The Option is to distinguish between nullary methods and empty-param-list - * methods. - */ - private type PolyMethodCreator = List[Symbol] => (Option[List[Type]], Type) - - private def enterNewClass(owner: Symbol, name: TypeName, parents: List[Type], flags: Long = 0L): ClassSymbol = { - val clazz = owner.newClassSymbol(name, NoPosition, flags) - clazz setInfoAndEnter ClassInfoType(parents, newScope, clazz) - } - private def newMethod(owner: Symbol, name: TermName, formals: List[Type], restpe: Type, flags: Long = 0L): MethodSymbol = { - val msym = owner.newMethod(name.encode, NoPosition, flags) - val params = msym.newSyntheticValueParams(formals) - msym setInfo MethodType(params, restpe) - } - private def enterNewMethod(owner: Symbol, name: TermName, formals: List[Type], restpe: Type, flags: Long = 0L): MethodSymbol = - owner.info.decls enter newMethod(owner, name, formals, restpe, flags) - - // the scala value classes - trait ValueClassDefinitions { - self: DefinitionsClass => - - import ClassfileConstants._ - - private val nameToWeight = Map[Name, Int]( - tpnme.Byte -> 2, - tpnme.Char -> 3, - tpnme.Short -> 4, - tpnme.Int -> 12, - tpnme.Long -> 24, - tpnme.Float -> 48, - tpnme.Double -> 96 - ) - - private val nameToTag = Map[Name, Char]( - tpnme.Byte -> BYTE_TAG, - tpnme.Char -> CHAR_TAG, - tpnme.Short -> SHORT_TAG, - tpnme.Int -> INT_TAG, - tpnme.Long -> LONG_TAG, - tpnme.Float -> FLOAT_TAG, - tpnme.Double -> DOUBLE_TAG, - tpnme.Boolean -> BOOL_TAG, - tpnme.Unit -> VOID_TAG - ) - - private def catastrophicFailure() = - abort("Could not find value classes! This is a catastrophic failure. scala " + - scala.util.Properties.versionString) - - private def valueClassSymbol(name: TypeName): ClassSymbol = { - getMember(ScalaPackageClass, name) match { - case x: ClassSymbol => x - case _ => catastrophicFailure() - } - } - private def valueClassCompanion(name: TermName): ModuleSymbol = { - getMember(ScalaPackageClass, name) match { - case x: ModuleSymbol => x - case _ => catastrophicFailure() - } - } - private def valueCompanionMember(className: Name, methodName: TermName): TermSymbol = - requiredMethod(valueClassCompanion(className.toTermName).moduleClass, methodName) - - private def classesMap[T](f: Name => T) = symbolsMap(ScalaValueClassesNoUnit, f) - private def symbolsMap[T](syms: List[Symbol], f: Name => T): Map[Symbol, T] = mapFrom(syms)(x => f(x.name)) - private def symbolsMapFilt[T](syms: List[Symbol], p: Name => Boolean, f: Name => T) = symbolsMap(syms filter (x => p(x.name)), f) - - private def boxedName(name: Name) = sn.Boxed(name.toTypeName) - - lazy val abbrvTag = symbolsMap(ScalaValueClasses, nameToTag) withDefaultValue OBJECT_TAG - lazy val numericWeight = symbolsMapFilt(ScalaValueClasses, nameToWeight.keySet, nameToWeight) - lazy val boxedModule = classesMap(x => getModule(boxedName(x))) - lazy val boxedClass = classesMap(x => getClassByName(boxedName(x))) - lazy val refClass = classesMap(x => getRequiredClass("scala.runtime." + x + "Ref")) - lazy val volatileRefClass = classesMap(x => getRequiredClass("scala.runtime.Volatile" + x + "Ref")) - lazy val boxMethod = classesMap(x => valueCompanionMember(x, nme.box)) - lazy val unboxMethod = classesMap(x => valueCompanionMember(x, nme.unbox)) - - def isNumericSubClass(sub: Symbol, sup: Symbol) = ( - (numericWeight contains sub) - && (numericWeight contains sup) - && (numericWeight(sup) % numericWeight(sub) == 0) - ) - - /** Is symbol a numeric value class? */ - def isNumericValueClass(sym: Symbol) = ScalaNumericValueClasses contains sym - - def isGetClass(sym: Symbol) = - (sym.name == nme.getClass_) && flattensToEmpty(sym.paramss) - - lazy val UnitClass = valueClassSymbol(tpnme.Unit) - lazy val ByteClass = valueClassSymbol(tpnme.Byte) - lazy val ShortClass = valueClassSymbol(tpnme.Short) - lazy val CharClass = valueClassSymbol(tpnme.Char) - lazy val IntClass = valueClassSymbol(tpnme.Int) - lazy val LongClass = valueClassSymbol(tpnme.Long) - lazy val FloatClass = valueClassSymbol(tpnme.Float) - lazy val DoubleClass = valueClassSymbol(tpnme.Double) - lazy val BooleanClass = valueClassSymbol(tpnme.Boolean) - lazy val Boolean_and = requiredMethod(BooleanClass, nme.ZAND) - lazy val Boolean_or = requiredMethod(BooleanClass, nme.ZOR) - lazy val Boolean_not = requiredMethod(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 ScalaNumericValueClasses = ScalaValueClasses filterNot Set[Symbol](UnitClass, BooleanClass) - lazy val ScalaValueClassesNoUnit = ScalaValueClasses filterNot (_ eq UnitClass) - lazy val ScalaValueClasses: List[ClassSymbol] = List( - UnitClass, - BooleanClass, - ByteClass, - ShortClass, - CharClass, - IntClass, - LongClass, - FloatClass, - DoubleClass - ) - def ScalaValueClassCompanions: List[Symbol] = ScalaValueClasses map (_.companionSymbol) - def ScalaPrimitiveValueClasses: List[ClassSymbol] = ScalaValueClasses - } - - abstract class DefinitionsClass extends DefinitionsApi with ValueClassDefinitions { - private var isInitialized = false - def isDefinitionsInitialized = isInitialized - - // symbols related to packages - var emptypackagescope: Scope = null //debug - - @deprecated("Moved to rootMirror.RootPackage", "2.10.0") - val RootPackage: ModuleSymbol = rootMirror.RootPackage - - @deprecated("Moved to rootMirror.RootClass", "2.10.0") - val RootClass: ClassSymbol = rootMirror.RootClass - - @deprecated("Moved to rootMirror.EmptyPackage", "2.10.0") - val EmptyPackage: ModuleSymbol = rootMirror.EmptyPackage - - @deprecated("Moved to rootMirror.EmptyPackageClass", "2.10.0") - val EmptyPackageClass: ClassSymbol = rootMirror.EmptyPackageClass - - // It becomes tricky to create dedicated objects for other symbols because - // of initialization order issues. - lazy val JavaLangPackage = getRequiredPackage(sn.JavaLang) - lazy val JavaLangPackageClass = JavaLangPackage.moduleClass.asClass - lazy val ScalaPackage = getRequiredPackage(nme.scala_) - lazy val ScalaPackageClass = ScalaPackage.moduleClass.asClass - lazy val RuntimePackage = getRequiredPackage("scala.runtime") - lazy val RuntimePackageClass = RuntimePackage.moduleClass.asClass - - lazy val JavaLangEnumClass = requiredClass[java.lang.Enum[_]] - - // convenient one-argument parameter lists - lazy val anyparam = List(AnyClass.tpe) - lazy val anyvalparam = List(AnyValClass.typeRef) - lazy val anyrefparam = List(AnyRefClass.typeRef) - - // 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 => UnitClassShort - case java.lang.Byte.TYPE => ByteClass - case java.lang.Character.TYPE => CharClass - case java.lang.Short.TYPE => ShortClass - case java.lang.Integer.TYPE => IntClass - case java.lang.Long.TYPE => LongClass - case java.lang.Float.TYPE => FloatClass - case java.lang.Double.TYPE => DoubleClass - case java.lang.Boolean.TYPE => BooleanClass - case _ => NoSymbol - } - def valueClassToJavaType(sym: Symbol): Class[_] = sym match { - case UnitClass => java.lang.Void.TYPE - case ByteClass => java.lang.Byte.TYPE - case CharClass => java.lang.Character.TYPE - case ShortClass => java.lang.Short.TYPE - case IntClass => java.lang.Integer.TYPE - case LongClass => java.lang.Long.TYPE - case FloatClass => java.lang.Float.TYPE - case DoubleClass => java.lang.Double.TYPE - case BooleanClass => java.lang.Boolean.TYPE - case _ => null - } - - /** Fully initialize the symbol, type, or scope. - */ - def fullyInitializeSymbol(sym: Symbol): Symbol = { - sym.initialize - fullyInitializeType(sym.info) - fullyInitializeType(sym.tpe) - sym - } - def fullyInitializeType(tp: Type): Type = { - tp.typeParams foreach fullyInitializeSymbol - tp.paramss.flatten foreach fullyInitializeSymbol - tp - } - def fullyInitializeScope(scope: Scope): Scope = { - scope.sorted foreach fullyInitializeSymbol - scope - } - /** Is this type equivalent to Any, AnyVal, or AnyRef? */ - def isTrivialTopType(tp: Type) = ( - tp =:= AnyClass.tpe - || tp =:= AnyValClass.tpe - || tp =:= AnyRefClass.tpe - ) - /** Does this type have a parent which is none of Any, AnyVal, or AnyRef? */ - def hasNonTrivialParent(tp: Type) = tp.parents exists (t => !isTrivialTopType(tp)) - - private def fixupAsAnyTrait(tpe: Type): Type = tpe match { - case ClassInfoType(parents, decls, clazz) => - if (parents.head.typeSymbol == AnyClass) tpe - else { - assert(parents.head.typeSymbol == ObjectClass, parents) - ClassInfoType(AnyClass.tpe :: parents.tail, decls, clazz) - } - case PolyType(tparams, restpe) => - PolyType(tparams, fixupAsAnyTrait(restpe)) -// case _ => tpe - } - - // top types - lazy val AnyClass = enterNewClass(ScalaPackageClass, tpnme.Any, Nil, ABSTRACT) - lazy val AnyRefClass = newAlias(ScalaPackageClass, tpnme.AnyRef, ObjectClass.tpe) - 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 - - // Note: this is not the type alias AnyRef, it's a companion-like - // object used by the @specialize annotation. - lazy val AnyRefModule = getMemberModule(ScalaPackageClass, nme.AnyRef) - @deprecated("Use AnyRefModule", "2.10.0") - def Predef_AnyRef = AnyRefModule - - lazy val AnyValClass: ClassSymbol = (ScalaPackageClass.info member tpnme.AnyVal orElse { - val anyval = enterNewClass(ScalaPackageClass, tpnme.AnyVal, List(AnyClass.tpe, NotNullClass.tpe), 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 = requiredMethod(AnyValClass, nme.getClass_) - - // bottom types - lazy val RuntimeNothingClass = getClassByName(fulltpnme.RuntimeNothing) - lazy val RuntimeNullClass = getClassByName(fulltpnme.RuntimeNull) - - sealed abstract class BottomClassSymbol(name: TypeName, parent: Symbol) extends ClassSymbol(ScalaPackageClass, NoPosition, name) { - locally { - this initFlags ABSTRACT | Final - this setInfoAndEnter ClassInfoType(List(parent.tpe), newScope, this) - } - final override def isBottomClass = true - } - final object NothingClass extends BottomClassSymbol(tpnme.Nothing, AnyClass) { - override def isSubClass(that: Symbol) = true - } - final object NullClass extends BottomClassSymbol(tpnme.Null, AnyRefClass) { - override def isSubClass(that: Symbol) = ( - (that eq AnyClass) - || (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] - lazy val IndexOutOfBoundsExceptionClass = getClassByName(sn.IOOBException) - lazy val InvocationTargetExceptionClass = getClassByName(sn.InvTargetException) - lazy val MatchErrorClass = requiredClass[MatchError] - lazy val NonLocalReturnControlClass = requiredClass[scala.runtime.NonLocalReturnControl[_]] - lazy val NullPointerExceptionClass = getClassByName(sn.NPException) - lazy val ThrowableClass = getClassByName(sn.Throwable) - lazy val UninitializedErrorClass = requiredClass[UninitializedFieldError] - - // fundamental reference classes - lazy val PartialFunctionClass = requiredClass[PartialFunction[_,_]] - lazy val AbstractPartialFunctionClass = requiredClass[scala.runtime.AbstractPartialFunction[_,_]] - lazy val SymbolClass = requiredClass[scala.Symbol] - lazy val StringClass = requiredClass[java.lang.String] - lazy val StringModule = StringClass.linkedClassOfClass - lazy val ClassClass = requiredClass[java.lang.Class[_]] - def Class_getMethod = requiredMethod(ClassClass, nme.getMethod_) - lazy val DynamicClass = requiredClass[Dynamic] - - // fundamental modules - lazy val SysPackage = getPackageObject("scala.sys") - def Sys_error = requiredMethod(SysPackage, nme.error) - - // Modules whose members are in the default namespace - // SI-5941: ScalaPackage and JavaLangPackage are never ever shared between mirrors - // as a result, `Int` becomes `scala.Int` and `String` becomes `java.lang.String` - // I could just change `isOmittablePrefix`, but there's more to it, so I'm leaving this as a todo for now - lazy val UnqualifiedModules = List(PredefModule, ScalaPackage, JavaLangPackage) - // Those modules and their module classes - lazy val UnqualifiedOwners = UnqualifiedModules.toSet ++ UnqualifiedModules.map(_.moduleClass) - - lazy val PredefModule = requiredModule[scala.Predef.type] - lazy val PredefModuleClass = PredefModule.moduleClass - - def Predef_classOf = requiredMethod(PredefModule, nme.classOf) - def Predef_identity = requiredMethod(PredefModule, nme.identity) - def Predef_conforms = requiredMethod(PredefModule, nme.conforms) - def Predef_wrapRefArray = requiredMethod(PredefModule, nme.wrapRefArray) - def Predef_??? = requiredMethod(PredefModule, nme.???) - def Predef_implicitly = requiredMethod(PredefModule, nme.implicitly) - - /** Is `sym` a member of Predef with the given name? - * Note: DON't replace this by sym == Predef_conforms/etc, as Predef_conforms is a `def` - * which does a member lookup (it can't be a lazy val because we might reload Predef - * during resident compilations). - */ - def isPredefMemberNamed(sym: Symbol, name: Name) = ( - (sym.name == name) && (sym.owner == PredefModule.moduleClass) - ) - - /** Specialization. - */ - lazy val SpecializableModule = requiredModule[Specializable] - lazy val GroupOfSpecializable = getMemberClass(SpecializableModule, tpnme.Group) - - lazy val ConsoleModule = requiredModule[scala.Console.type] - lazy val ScalaRunTimeModule = requiredModule[scala.runtime.ScalaRunTime.type] - lazy val SymbolModule = requiredModule[scala.Symbol.type] - lazy val Symbol_apply = requiredMethod(SymbolModule, nme.apply) - - def arrayApplyMethod = requiredMethod(ScalaRunTimeModule, nme.array_apply) - def arrayUpdateMethod = requiredMethod(ScalaRunTimeModule, nme.array_update) - def arrayLengthMethod = requiredMethod(ScalaRunTimeModule, nme.array_length) - def arrayCloneMethod = requiredMethod(ScalaRunTimeModule, nme.array_clone) - def ensureAccessibleMethod = requiredMethod(ScalaRunTimeModule, nme.ensureAccessible) - def scalaRuntimeSameElements = requiredMethod(ScalaRunTimeModule, nme.sameElements) - def arrayClassMethod = requiredMethod(ScalaRunTimeModule, nme.arrayClass) - def arrayElementClassMethod = requiredMethod(ScalaRunTimeModule, nme.arrayElementClass) - - // classes with special meanings - lazy val StringAddClass = requiredClass[scala.runtime.StringAdd] - lazy val ArrowAssocClass = getRequiredClass("scala.Predef.ArrowAssoc") // SI-5731 - lazy val StringAdd_+ = requiredMethod(StringAddClass, nme.PLUS) - lazy val NotNullClass = getRequiredClass("scala.NotNull") - lazy val ScalaNumberClass = requiredClass[scala.math.ScalaNumber] - lazy val TraitSetterAnnotationClass = requiredClass[scala.runtime.TraitSetter] - lazy val DelayedInitClass = requiredClass[scala.DelayedInit] - def delayedInitMethod = requiredMethod(DelayedInitClass, nme.delayedInit) - // a dummy value that communicates that a delayedInit call is compiler-generated - // from phase UnCurry to phase Constructors - // !!! This is not used anywhere (it was checked in that way.) - // def delayedInitArgVal = EmptyPackageClass.newValue(NoPosition, nme.delayedInitArg) - // .setInfo(UnitClass.tpe) - - lazy val TypeConstraintClass = requiredClass[scala.annotation.TypeConstraint] - lazy val SingletonClass = enterNewClass(ScalaPackageClass, tpnme.Singleton, anyparam, 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 - lazy val CloneableClass = requiredClass[scala.Cloneable] - lazy val JavaCloneableClass = requiredClass[java.lang.Cloneable] - lazy val JavaNumberClass = requiredClass[java.lang.Number] - 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 EqualsPatternClass = specialPolyClass(tpnme.EQUALS_PATTERN_NAME, 0L)(_ => AnyClass.tpe) - 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)) - - def isByNameParamType(tp: Type) = tp.typeSymbol == ByNameParamClass - def isScalaRepeatedParamType(tp: Type) = tp.typeSymbol == RepeatedParamClass - def isJavaRepeatedParamType(tp: Type) = tp.typeSymbol == JavaRepeatedParamClass - def isRepeatedParamType(tp: Type) = isScalaRepeatedParamType(tp) || isJavaRepeatedParamType(tp) - def isRepeated(param: Symbol) = isRepeatedParamType(param.tpe) - def isCastSymbol(sym: Symbol) = sym == Any_asInstanceOf || sym == Object_asInstanceOf - - def isJavaVarArgsMethod(m: Symbol) = m.isMethod && isJavaVarArgs(m.info.params) - def isJavaVarArgs(params: Seq[Symbol]) = params.nonEmpty && isJavaRepeatedParamType(params.last.tpe) - def isScalaVarArgs(params: Seq[Symbol]) = params.nonEmpty && isScalaRepeatedParamType(params.last.tpe) - def isVarArgsList(params: Seq[Symbol]) = params.nonEmpty && isRepeatedParamType(params.last.tpe) - def isVarArgTypes(formals: Seq[Type]) = formals.nonEmpty && isRepeatedParamType(formals.last) - - def hasRepeatedParam(tp: Type): Boolean = tp match { - case MethodType(formals, restpe) => isScalaVarArgs(formals) || hasRepeatedParam(restpe) - case PolyType(_, restpe) => hasRepeatedParam(restpe) - case _ => false - } - - def repeatedToSeq(tp: Type): Type = (tp baseType RepeatedParamClass) match { - case TypeRef(_, RepeatedParamClass, arg :: Nil) => seqType(arg) - case _ => tp - } - - def seqToRepeated(tp: Type): Type = (tp baseType SeqClass) match { - case TypeRef(_, SeqClass, arg :: Nil) => scalaRepeatedType(arg) - case _ => tp - } - - def isPrimitiveArray(tp: Type) = tp match { - case TypeRef(_, ArrayClass, arg :: Nil) => isPrimitiveValueClass(arg.typeSymbol) - case _ => false - } - def isReferenceArray(tp: Type) = tp match { - case TypeRef(_, ArrayClass, arg :: Nil) => arg <:< AnyRefClass.tpe - case _ => false - } - def isArrayOfSymbol(tp: Type, elem: Symbol) = tp match { - case TypeRef(_, ArrayClass, arg :: Nil) => arg.typeSymbol == elem - case _ => false - } - - lazy val MatchingStrategyClass = getRequiredClass("scala.MatchingStrategy") - - // collections classes - lazy val ConsClass = requiredClass[scala.collection.immutable.::[_]] - lazy val IterableClass = requiredClass[scala.collection.Iterable[_]] - lazy val IteratorClass = requiredClass[scala.collection.Iterator[_]] - lazy val ListClass = requiredClass[scala.collection.immutable.List[_]] - lazy val SeqClass = requiredClass[scala.collection.Seq[_]] - lazy val StringBuilderClass = requiredClass[scala.collection.mutable.StringBuilder] - lazy val TraversableClass = requiredClass[scala.collection.Traversable[_]] - - lazy val ListModule = requiredModule[scala.collection.immutable.List.type] - lazy val List_apply = requiredMethod(ListModule, nme.apply) - lazy val NilModule = requiredModule[scala.collection.immutable.Nil.type] - lazy val SeqModule = requiredModule[scala.collection.Seq.type] - lazy val IteratorModule = requiredModule[scala.collection.Iterator.type] - lazy val Iterator_apply = requiredMethod(IteratorModule, nme.apply) - - // arrays and their members - lazy val ArrayModule = requiredModule[scala.Array.type] - lazy val ArrayModule_overloadedApply = requiredMethod(ArrayModule, nme.apply) - lazy val ArrayClass = getRequiredClass("scala.Array") // requiredClass[scala.Array[_]] - lazy val Array_apply = requiredMethod(ArrayClass, nme.apply) - lazy val Array_update = requiredMethod(ArrayClass, nme.update) - lazy val Array_length = requiredMethod(ArrayClass, nme.length) - lazy val Array_clone = requiredMethod(ArrayClass, nme.clone_) - - // reflection / structural types - lazy val SoftReferenceClass = requiredClass[java.lang.ref.SoftReference[_]] - lazy val WeakReferenceClass = requiredClass[java.lang.ref.WeakReference[_]] - lazy val MethodClass = getClassByName(sn.MethodAsObject) - def methodClass_setAccessible = requiredMethod(MethodClass, nme.setAccessible) - lazy val EmptyMethodCacheClass = requiredClass[scala.runtime.EmptyMethodCache] - lazy val MethodCacheClass = requiredClass[scala.runtime.MethodCache] - def methodCache_find = requiredMethod(MethodCacheClass, nme.find_) - def methodCache_add = requiredMethod(MethodCacheClass, nme.add_) - - // scala.reflect - lazy val ReflectPackage = requiredModule[scala.reflect.`package`.type] - lazy val ReflectApiPackage = getPackageObjectIfDefined("scala.reflect.api") // defined in scala-reflect.jar, so we need to be careful - lazy val ReflectRuntimePackage = getPackageObjectIfDefined("scala.reflect.runtime") // defined in scala-reflect.jar, so we need to be careful - def ReflectRuntimeUniverse = if (ReflectRuntimePackage != NoSymbol) getMemberValue(ReflectRuntimePackage, nme.universe) else NoSymbol - def ReflectRuntimeCurrentMirror = if (ReflectRuntimePackage != NoSymbol) requiredMethod(ReflectRuntimePackage, nme.currentMirror) else NoSymbol - - lazy val PartialManifestClass = getTypeMember(ReflectPackage, tpnme.ClassManifest) - lazy val PartialManifestModule = requiredModule[scala.reflect.ClassManifestFactory.type] - lazy val FullManifestClass = requiredClass[scala.reflect.Manifest[_]] - lazy val FullManifestModule = requiredModule[scala.reflect.ManifestFactory.type] - lazy val OptManifestClass = requiredClass[scala.reflect.OptManifest[_]] - lazy val NoManifest = requiredModule[scala.reflect.NoManifest.type] - - lazy val ExprsClass = getClassIfDefined("scala.reflect.api.Exprs") // defined in scala-reflect.jar, so we need to be careful - lazy val ExprClass = if (ExprsClass != NoSymbol) getMemberClass(ExprsClass, tpnme.Expr) else NoSymbol - def ExprSplice = if (ExprsClass != NoSymbol) requiredMethod(ExprClass, nme.splice) else NoSymbol - def ExprValue = if (ExprsClass != NoSymbol) requiredMethod(ExprClass, nme.value) else NoSymbol - lazy val ExprModule = if (ExprsClass != NoSymbol) getMemberModule(ExprsClass, nme.Expr) else NoSymbol - - lazy val ClassTagModule = requiredModule[scala.reflect.ClassTag[_]] - lazy val ClassTagClass = requiredClass[scala.reflect.ClassTag[_]] - lazy val TypeTagsClass = getClassIfDefined("scala.reflect.api.TypeTags") // defined in scala-reflect.jar, so we need to be careful - lazy val WeakTypeTagClass = if (TypeTagsClass != NoSymbol) getMemberClass(TypeTagsClass, tpnme.WeakTypeTag) else NoSymbol - lazy val WeakTypeTagModule = if (TypeTagsClass != NoSymbol) getMemberModule(TypeTagsClass, nme.WeakTypeTag) else NoSymbol - lazy val TypeTagClass = if (TypeTagsClass != NoSymbol) getMemberClass(TypeTagsClass, tpnme.TypeTag) else NoSymbol - lazy val TypeTagModule = if (TypeTagsClass != NoSymbol) getMemberModule(TypeTagsClass, nme.TypeTag) else NoSymbol - def materializeClassTag = requiredMethod(ReflectPackage, nme.materializeClassTag) - def materializeWeakTypeTag = if (ReflectApiPackage != NoSymbol) requiredMethod(ReflectApiPackage, nme.materializeWeakTypeTag) else NoSymbol - def materializeTypeTag = if (ReflectApiPackage != NoSymbol) requiredMethod(ReflectApiPackage, nme.materializeTypeTag) else NoSymbol - - lazy val ApiUniverseClass = getClassIfDefined("scala.reflect.api.Universe") // defined in scala-reflect.jar, so we need to be careful - def ApiUniverseReify = if (ApiUniverseClass != NoSymbol) requiredMethod(ApiUniverseClass, nme.reify) else NoSymbol - lazy val JavaUniverseClass = getClassIfDefined("scala.reflect.api.JavaUniverse") // defined in scala-reflect.jar, so we need to be careful - - lazy val MirrorClass = getClassIfDefined("scala.reflect.api.Mirror") // defined in scala-reflect.jar, so we need to be careful - - lazy val TypeCreatorClass = getClassIfDefined("scala.reflect.api.TypeCreator") // defined in scala-reflect.jar, so we need to be careful - lazy val TreeCreatorClass = getClassIfDefined("scala.reflect.api.TreeCreator") // defined in scala-reflect.jar, so we need to be careful - - lazy val MacroContextClass = getClassIfDefined("scala.reflect.macros.Context") // defined in scala-reflect.jar, so we need to be careful - def MacroContextPrefix = if (MacroContextClass != NoSymbol) requiredMethod(MacroContextClass, nme.prefix) else NoSymbol - def MacroContextPrefixType = if (MacroContextClass != NoSymbol) getTypeMember(MacroContextClass, tpnme.PrefixType) else NoSymbol - def MacroContextUniverse = if (MacroContextClass != NoSymbol) requiredMethod(MacroContextClass, nme.universe) else NoSymbol - def MacroContextMirror = if (MacroContextClass != NoSymbol) requiredMethod(MacroContextClass, nme.mirror) else NoSymbol - lazy val MacroImplAnnotation = requiredClass[scala.reflect.macros.internal.macroImpl] - - lazy val StringContextClass = requiredClass[scala.StringContext] - def StringContext_f = requiredMethod(StringContextClass, nme.f) - - - // Option classes - lazy val OptionClass: ClassSymbol = requiredClass[Option[_]] - lazy val SomeClass: ClassSymbol = requiredClass[Some[_]] - lazy val NoneModule: ModuleSymbol = requiredModule[scala.None.type] - lazy val SomeModule: ModuleSymbol = requiredModule[scala.Some.type] - - def compilerTypeFromTag(tt: ApiUniverse # WeakTypeTag[_]): Type = tt.in(rootMirror).tpe - def compilerSymbolFromTag(tt: ApiUniverse # WeakTypeTag[_]): Symbol = tt.in(rootMirror).tpe.typeSymbol - - // The given symbol represents either String.+ or StringAdd.+ - def isStringAddition(sym: Symbol) = sym == String_+ || sym == StringAdd_+ - def isArrowAssoc(sym: Symbol) = ArrowAssocClass.tpe.decls.toList contains sym - - // The given symbol is a method with the right name and signature to be a runnable java program. - def isJavaMainMethod(sym: Symbol) = (sym.name == nme.main) && (sym.info match { - case MethodType(p :: Nil, restpe) => isArrayOfSymbol(p.tpe, StringClass) && restpe.typeSymbol == UnitClass - case _ => false - }) - // The given class has a main method. - def hasJavaMainMethod(sym: Symbol): Boolean = - (sym.tpe member nme.main).alternatives exists isJavaMainMethod - def hasJavaMainMethod(path: String): Boolean = - hasJavaMainMethod(getModuleIfDefined(path)) - - def isOptionType(tp: Type) = tp.typeSymbol isSubClass OptionClass - def isSomeType(tp: Type) = tp.typeSymbol eq SomeClass - def isNoneType(tp: Type) = tp.typeSymbol eq NoneModule - - // Product, Tuple, Function, AbstractFunction - private def mkArityArray(name: String, arity: Int, countFrom: Int): Array[ClassSymbol] = { - val list = countFrom to arity map (i => getRequiredClass("scala." + name + i)) - list.toArray - } - def prepend[S >: ClassSymbol : ClassTag](elem0: S, elems: Array[ClassSymbol]): Array[S] = elem0 +: elems - - private def aritySpecificType[S <: Symbol](symbolArray: Array[S], args: List[Type], others: Type*): Type = { - val arity = args.length - if (arity >= symbolArray.length) NoType - else appliedType(symbolArray(arity), args ++ others: _*) - } - - val MaxTupleArity, MaxProductArity, MaxFunctionArity = 22 - lazy val ProductClass: Array[ClassSymbol] = prepend(UnitClass, mkArityArray("Product", MaxProductArity, 1)) - lazy val TupleClass: Array[Symbol] = prepend(NoSymbol, mkArityArray("Tuple", MaxTupleArity, 1)) - lazy val FunctionClass = mkArityArray("Function", MaxFunctionArity, 0) - lazy val AbstractFunctionClass = mkArityArray("runtime.AbstractFunction", MaxFunctionArity, 0) - - /** Creators for TupleN, ProductN, FunctionN. */ - def tupleType(elems: List[Type]) = aritySpecificType(TupleClass, elems) - def productType(elems: List[Type]) = aritySpecificType(ProductClass, elems) - def functionType(formals: List[Type], restpe: Type) = aritySpecificType(FunctionClass, formals, restpe) - def abstractFunctionType(formals: List[Type], restpe: Type) = aritySpecificType(AbstractFunctionClass, formals, restpe) - - def wrapArrayMethodName(elemtp: Type): TermName = elemtp.typeSymbol match { - case ByteClass => nme.wrapByteArray - case ShortClass => nme.wrapShortArray - case CharClass => nme.wrapCharArray - case IntClass => nme.wrapIntArray - case LongClass => nme.wrapLongArray - case FloatClass => nme.wrapFloatArray - case DoubleClass => nme.wrapDoubleArray - case BooleanClass => nme.wrapBooleanArray - case UnitClass => nme.wrapUnitArray - case _ => - if ((elemtp <:< AnyRefClass.tpe) && !isPhantomClass(elemtp.typeSymbol)) nme.wrapRefArray - else nme.genericWrapArray - } - - @deprecated("Use isTupleType", "2.10.0") - def isTupleTypeOrSubtype(tp: Type) = isTupleType(tp) - - def tupleField(n: Int, j: Int) = getMemberValue(TupleClass(n), nme.productAccessorName(j)) - // NOTE: returns true for NoSymbol since it's included in the TupleClass array -- is this intensional? - def isTupleSymbol(sym: Symbol) = TupleClass contains unspecializedSymbol(sym) - def isProductNClass(sym: Symbol) = ProductClass contains sym - - def unspecializedSymbol(sym: Symbol): Symbol = { - if (sym hasFlag SPECIALIZED) { - // add initialization from its generic class constructor - val genericName = nme.unspecializedName(sym.name) - val member = sym.owner.info.decl(genericName.toTypeName) - member - } - else sym - } - - // Checks whether the given type is true for the given condition, - // or if it is a specialized subtype of a type for which it is true. - // - // Origins notes: - // An issue was introduced with specialization in that the implementation - // of "isTupleType" in Definitions relied upon sym == TupleClass(elems.length). - // This test is untrue for specialized tuples, causing mysterious behavior - // because only some tuples are specialized. - def isPossiblySpecializedType(tp: Type)(cond: Type => Boolean) = { - cond(tp) || (tp match { - case TypeRef(pre, sym, args) if sym hasFlag SPECIALIZED => - cond(tp baseType unspecializedSymbol(sym)) - case _ => - false - }) - } - // No normalization. - def isTupleTypeDirect(tp: Type) = isPossiblySpecializedType(tp) { - case TypeRef(_, sym, args) if args.nonEmpty => - val len = args.length - len <= MaxTupleArity && sym == TupleClass(len) - case _ => false - } - def isTupleType(tp: Type) = isTupleTypeDirect(tp.normalize) - - lazy val ProductRootClass: ClassSymbol = requiredClass[scala.Product] - def Product_productArity = requiredMethod(ProductRootClass, nme.productArity) - def Product_productElement = requiredMethod(ProductRootClass, nme.productElement) - def Product_iterator = requiredMethod(ProductRootClass, nme.productIterator) - def Product_productPrefix = requiredMethod(ProductRootClass, nme.productPrefix) - def Product_canEqual = requiredMethod(ProductRootClass, nme.canEqual_) - // def Product_productElementName = requiredMethod(ProductRootClass, nme.productElementName) - - def productProj(z:Symbol, j: Int): TermSymbol = getMemberValue(z, nme.productAccessorName(j)) - def productProj(n: Int, j: Int): TermSymbol = productProj(ProductClass(n), j) - - /** returns true if this type is exactly ProductN[T1,...,Tn], not some subclass */ - def isExactProductType(tp: Type): Boolean = isProductNClass(tp.typeSymbol) - - /** if tpe <: ProductN[T1,...,TN], returns List(T1,...,TN) else Nil */ - def getProductArgs(tpe: Type): List[Type] = tpe.baseClasses find isProductNClass match { - case Some(x) => tpe.baseType(x).typeArgs - case _ => Nil - } - - def unapplyUnwrap(tpe:Type) = tpe.finalResultType.normalize match { - case RefinedType(p :: _, _) => p.normalize - case tp => tp - } - - def functionApply(n: Int) = requiredMethod(FunctionClass(n), nme.apply) - - def abstractFunctionForFunctionType(tp: Type) = - if (isFunctionType(tp)) abstractFunctionType(tp.typeArgs.init, tp.typeArgs.last) - else NoType - - def isFunctionType(tp: Type): Boolean = tp.normalize match { - case TypeRef(_, sym, args) if args.nonEmpty => - val arity = args.length - 1 // -1 is the return type - arity <= MaxFunctionArity && sym == FunctionClass(arity) - case _ => - false - } - - def isPartialFunctionType(tp: Type): Boolean = { - val sym = tp.typeSymbol - (sym eq PartialFunctionClass) || (sym eq AbstractPartialFunctionClass) - } - - def isSeqType(tp: Type) = elementType(SeqClass, tp.normalize) != NoType - - def elementType(container: Symbol, tp: Type): Type = tp match { - case TypeRef(_, `container`, arg :: Nil) => arg - case _ => NoType - } - - def arrayType(arg: Type) = appliedType(ArrayClass, arg) - def byNameType(arg: Type) = appliedType(ByNameParamClass, arg) - def iteratorOfType(tp: Type) = appliedType(IteratorClass, tp) - def javaRepeatedType(arg: Type) = appliedType(JavaRepeatedParamClass, arg) - def optionType(tp: Type) = appliedType(OptionClass, tp) - def scalaRepeatedType(arg: Type) = appliedType(RepeatedParamClass, arg) - def seqType(arg: Type) = appliedType(SeqClass, arg) - def someType(tp: Type) = appliedType(SomeClass, tp) - - def StringArray = arrayType(StringClass.tpe) - lazy val ObjectArray = arrayType(ObjectClass.tpe) - - def ClassType(arg: Type) = - if (phase.erasedTypes || forMSIL) ClassClass.tpe - else appliedType(ClassClass, arg) - - def EnumType(sym: Symbol) = - // given (in java): "class A { enum E { VAL1 } }" - // - sym: the symbol of the actual enumeration value (VAL1) - // - .owner: the ModuleClassSymbol of the enumeration (object E) - // - .linkedClassOfClass: the ClassSymbol of the enumeration (class E) - sym.owner.linkedClassOfClass.tpe - - def vmClassType(arg: Type): Type = ClassType(arg) - def vmSignature(sym: Symbol, info: Type): String = signature(info) // !!! - - /** Given a class symbol C with type parameters T1, T2, ... Tn - * which have upper/lower bounds LB1/UB1, LB1/UB2, ..., LBn/UBn, - * returns an existential type of the form - * - * C[E1, ..., En] forSome { E1 >: LB1 <: UB1 ... en >: LBn <: UBn }. - */ - def classExistentialType(clazz: Symbol): Type = - newExistentialType(clazz.typeParams, clazz.tpe) - - /** Given type U, creates a Type representing Class[_ <: U]. - */ - def boundedClassType(upperBound: Type) = - appliedTypeAsUpperBounds(ClassClass.typeRef, List(upperBound)) - - /** To avoid unchecked warnings on polymorphic classes, translate - * a Foo[T] into a Foo[_] for use in the pattern matcher. - */ - @deprecated("Use classExistentialType", "2.10.0") - def typeCaseType(clazz: Symbol): Type = classExistentialType(clazz) - - // - // .NET backend - // - - lazy val ComparatorClass = getRequiredClass("scala.runtime.Comparator") - // System.ValueType - lazy val ValueTypeClass: ClassSymbol = getClassByName(sn.ValueType) - // System.MulticastDelegate - lazy val DelegateClass: ClassSymbol = getClassByName(sn.Delegate) - var Delegate_scalaCallers: List[Symbol] = List() // Syncnote: No protection necessary yet as only for .NET where reflection is not supported. - // Symbol -> (Symbol, Type): scalaCaller -> (scalaMethodSym, DelegateType) - // var Delegate_scalaCallerInfos: HashMap[Symbol, (Symbol, Type)] = _ - lazy val Delegate_scalaCallerTargets: mutable.HashMap[Symbol, Symbol] = mutable.HashMap() - - def isCorrespondingDelegate(delegateType: Type, functionType: Type): Boolean = { - isSubType(delegateType, DelegateClass.tpe) && - (delegateType.member(nme.apply).tpe match { - case MethodType(delegateParams, delegateReturn) => - isFunctionType(functionType) && - (functionType.normalize match { - case TypeRef(_, _, args) => - (delegateParams.map(pt => { - if (pt.tpe == AnyClass.tpe) definitions.ObjectClass.tpe else pt}) - ::: List(delegateReturn)) == args - case _ => false - }) - case _ => false - }) - } - - // members of class scala.Any - lazy val Any_== = enterNewMethod(AnyClass, nme.EQ, anyparam, BooleanType, Final) - lazy val Any_!= = enterNewMethod(AnyClass, nme.NE, anyparam, BooleanType, Final) - lazy val Any_equals = enterNewMethod(AnyClass, nme.equals_, anyparam, BooleanType) - 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) - - // Any_getClass requires special handling. The return type is determined on - // a per-call-site basis as if the function being called were actually: - // - // // Assuming `target.getClass()` - // def getClass[T](target: T): Class[_ <: T] - // - // Since getClass is not actually a polymorphic method, this requires compiler - // 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, requiredMethod(ObjectClass, nme.getClass_).tpe.resultType, DEFERRED) - lazy val Any_isInstanceOf = newT1NullaryMethod(AnyClass, nme.isInstanceOf_, Final)(_ => BooleanType) - lazy val Any_asInstanceOf = newT1NullaryMethod(AnyClass, nme.asInstanceOf_, Final)(_.typeRef) - - // A type function from T => Class[U], used to determine the return - // type of getClass calls. The returned type is: - // - // 1. If T is a value type, Class[T]. - // 2. If T is a phantom type (Any or AnyVal), Class[_]. - // 3. If T is a local class, Class[_ <: |T|]. - // 4. Otherwise, Class[_ <: T]. - // - // Note: AnyVal cannot be Class[_ <: AnyVal] because if the static type of the - // receiver is AnyVal, it implies the receiver is boxed, so the correct - // class object is that of java.lang.Integer, not Int. - // - // TODO: If T is final, return type could be Class[T]. Should it? - def getClassReturnType(tp: Type): Type = { - val sym = tp.typeSymbol - - if (phase.erasedTypes) ClassClass.tpe - else if (isPrimitiveValueClass(sym)) ClassType(tp.widen) - else { - val eparams = typeParamsToExistentials(ClassClass, ClassClass.typeParams) - val upperBound = ( - if (isPhantomClass(sym)) AnyClass.tpe - else if (sym.isLocalClass) erasure.intersectionDominator(tp.parents) - else tp.widen - ) - - existentialAbstraction( - eparams, - ClassType((eparams.head setInfo TypeBounds.upper(upperBound)).tpe) - ) - } - } - - /** Remove references to class Object (other than the head) in a list of parents */ - def removeLaterObjects(tps: List[Type]): List[Type] = tps match { - case Nil => Nil - case x :: xs => x :: xs.filterNot(_.typeSymbol == ObjectClass) - } - /** Remove all but one reference to class Object from a list of parents. */ - def removeRedundantObjects(tps: List[Type]): List[Type] = tps match { - case Nil => Nil - case x :: xs => - if (x.typeSymbol == ObjectClass) - x :: xs.filterNot(_.typeSymbol == ObjectClass) - else - x :: removeRedundantObjects(xs) - } - /** Order a list of types with non-trait classes before others. */ - def classesFirst(tps: List[Type]): List[Type] = { - val (classes, others) = tps partition (t => t.typeSymbol.isClass && !t.typeSymbol.isTrait) - if (classes.isEmpty || others.isEmpty || (tps startsWith classes)) tps - else classes ::: others - } - /** The following transformations applied to a list of parents. - * If any parent is a class/trait, all parents which normalize to - * Object are discarded. Otherwise, all parents which normalize - * to Object except the first one found are discarded. - */ - def normalizedParents(parents: List[Type]): List[Type] = { - if (parents exists (t => (t.typeSymbol ne ObjectClass) && t.typeSymbol.isClass)) - parents filterNot (_.typeSymbol eq ObjectClass) - else - removeRedundantObjects(parents) - } - - def typeStringNoPackage(tp: Type) = - "" + tp stripPrefix tp.typeSymbol.enclosingPackage.fullName + "." - - def briefParentsString(parents: List[Type]) = - normalizedParents(parents) map typeStringNoPackage mkString " with " - - def parentsString(parents: List[Type]) = - normalizedParents(parents) mkString " with " - - def typeParamsString(tp: Type) = tp match { - case PolyType(tparams, _) => tparams map (_.defString) mkString ("[", ",", "]") - case _ => "" - } - def valueParamsString(tp: Type) = tp match { - case MethodType(params, _) => params map (_.defString) mkString ("(", ",", ")") - case _ => "" - } - - // members of class java.lang.{ Object, String } - - lazy val String_+ = enterNewMethod(StringClass, nme.raw.PLUS, anyparam, stringtype, Final) - // boxed classes - lazy val ObjectRefClass = requiredClass[scala.runtime.ObjectRef[_]] - lazy val VolatileObjectRefClass = requiredClass[scala.runtime.VolatileObjectRef[_]] - lazy val RuntimeStaticsModule = getRequiredModule("scala.runtime.Statics") - lazy val BoxesRunTimeModule = getRequiredModule("scala.runtime.BoxesRunTime") - lazy val BoxesRunTimeClass = BoxesRunTimeModule.moduleClass - lazy val BoxedNumberClass = getClassByName(sn.BoxedNumber) - lazy val BoxedCharacterClass = getClassByName(sn.BoxedCharacter) - lazy val BoxedBooleanClass = getClassByName(sn.BoxedBoolean) - lazy val BoxedByteClass = requiredClass[java.lang.Byte] - lazy val BoxedShortClass = requiredClass[java.lang.Short] - lazy val BoxedIntClass = requiredClass[java.lang.Integer] - lazy val BoxedLongClass = requiredClass[java.lang.Long] - lazy val BoxedFloatClass = requiredClass[java.lang.Float] - lazy val BoxedDoubleClass = requiredClass[java.lang.Double] - - lazy val Boxes_isNumberOrBool = getDecl(BoxesRunTimeClass, nme.isBoxedNumberOrBoolean) - lazy val Boxes_isNumber = getDecl(BoxesRunTimeClass, nme.isBoxedNumber) - - lazy val BoxedUnitClass = requiredClass[scala.runtime.BoxedUnit] - lazy val BoxedUnitModule = getRequiredModule("scala.runtime.BoxedUnit") - def BoxedUnit_UNIT = getMemberValue(BoxedUnitModule, nme.UNIT) - def BoxedUnit_TYPE = getMemberValue(BoxedUnitModule, nme.TYPE_) - - - // Annotations - lazy val BridgeClass = requiredClass[scala.annotation.bridge] - lazy val ElidableMethodClass = requiredClass[scala.annotation.elidable] - lazy val ImplicitNotFoundClass = requiredClass[scala.annotation.implicitNotFound] - lazy val MigrationAnnotationClass = requiredClass[scala.annotation.migration] - lazy val ScalaStrictFPAttr = requiredClass[scala.annotation.strictfp] - lazy val SerializableAttr = requiredClass[scala.annotation.serializable] // @serializable is deprecated - lazy val SwitchClass = requiredClass[scala.annotation.switch] - lazy val TailrecClass = requiredClass[scala.annotation.tailrec] - lazy val VarargsClass = requiredClass[scala.annotation.varargs] - lazy val uncheckedStableClass = requiredClass[scala.annotation.unchecked.uncheckedStable] - lazy val uncheckedVarianceClass = requiredClass[scala.annotation.unchecked.uncheckedVariance] - - lazy val BeanPropertyAttr = requiredClass[scala.beans.BeanProperty] - lazy val BooleanBeanPropertyAttr = requiredClass[scala.beans.BooleanBeanProperty] - lazy val CloneableAttr = requiredClass[scala.annotation.cloneable] - lazy val DeprecatedNameAttr = requiredClass[scala.deprecatedName] - lazy val DeprecatedInheritanceAttr = requiredClass[scala.deprecatedInheritance] - lazy val DeprecatedOverridingAttr = requiredClass[scala.deprecatedOverriding] - lazy val NativeAttr = requiredClass[scala.native] - lazy val RemoteAttr = requiredClass[scala.remote] - lazy val ScalaInlineClass = requiredClass[scala.inline] - lazy val ScalaNoInlineClass = requiredClass[scala.noinline] - lazy val SerialVersionUIDAttr = requiredClass[scala.SerialVersionUID] - lazy val SpecializedClass = requiredClass[scala.specialized] - lazy val ThrowsClass = requiredClass[scala.throws[_]] - lazy val TransientAttr = requiredClass[scala.transient] - lazy val UncheckedClass = requiredClass[scala.unchecked] - lazy val UnspecializedClass = requiredClass[scala.annotation.unspecialized] - lazy val VolatileAttr = requiredClass[scala.volatile] - - // Meta-annotations - lazy val BeanGetterTargetClass = requiredClass[meta.beanGetter] - lazy val BeanSetterTargetClass = requiredClass[meta.beanSetter] - lazy val FieldTargetClass = requiredClass[meta.field] - lazy val GetterTargetClass = requiredClass[meta.getter] - lazy val ParamTargetClass = requiredClass[meta.param] - lazy val SetterTargetClass = requiredClass[meta.setter] - lazy val ClassTargetClass = requiredClass[meta.companionClass] - lazy val ObjectTargetClass = requiredClass[meta.companionObject] - lazy val MethodTargetClass = requiredClass[meta.companionMethod] // TODO: module, moduleClass? package, packageObject? - lazy val LanguageFeatureAnnot = requiredClass[meta.languageFeature] - - // Language features - lazy val languageFeatureModule = getRequiredModule("scala.languageFeature") - lazy val experimentalModule = getMemberModule(languageFeatureModule, nme.experimental) - lazy val MacrosFeature = getLanguageFeature("macros", experimentalModule) - lazy val DynamicsFeature = getLanguageFeature("dynamics") - lazy val PostfixOpsFeature = getLanguageFeature("postfixOps") - lazy val ReflectiveCallsFeature = getLanguageFeature("reflectiveCalls") - lazy val ImplicitConversionsFeature = getLanguageFeature("implicitConversions") - lazy val HigherKindsFeature = getLanguageFeature("higherKinds") - lazy val ExistentialsFeature = getLanguageFeature("existentials") - - def isMetaAnnotation(sym: Symbol): Boolean = metaAnnotations(sym) || ( - // Trying to allow for deprecated locations - sym.isAliasType && isMetaAnnotation(sym.info.typeSymbol) - ) - lazy val metaAnnotations = Set[Symbol]( - FieldTargetClass, ParamTargetClass, - GetterTargetClass, SetterTargetClass, - BeanGetterTargetClass, BeanSetterTargetClass - ) - - lazy val AnnotationDefaultAttr: ClassSymbol = { - val attr = enterNewClass(RuntimePackageClass, tpnme.AnnotationDefaultATTR, List(AnnotationClass.tpe)) - // This attribute needs a constructor so that modifiers in parsed Java code make sense - attr.info.decls enter attr.newClassConstructor(NoPosition) - attr - } - - @deprecated("Moved to rootMirror.getClass", "2.10.0") - def getClass(fullname: Name): ClassSymbol = rootMirror.getClassByName(fullname) - - @deprecated("Moved to rootMirror.getModule", "2.10.0") - def getModule(fullname: Name): ModuleSymbol = rootMirror.getModule(fullname) - - private def fatalMissingSymbol(owner: Symbol, name: Name, what: String = "member") = { - throw new FatalError(owner + " does not have a " + what + " " + name) - } - - def getLanguageFeature(name: String, owner: Symbol = languageFeatureModule): Symbol = getMember(owner, newTypeName(name)) - - def termMember(owner: Symbol, name: String): Symbol = owner.info.member(newTermName(name)) - def typeMember(owner: Symbol, name: String): Symbol = owner.info.member(newTypeName(name)) - - def findNamedMember(fullName: Name, root: Symbol): Symbol = { - val segs = nme.segments(fullName.toString, fullName.isTermName) - if (segs.isEmpty || segs.head != root.simpleName) NoSymbol - else findNamedMember(segs.tail, root) - } - def findNamedMember(segs: List[Name], root: Symbol): Symbol = - if (segs.isEmpty) root - else findNamedMember(segs.tail, root.info member segs.head) - - def getMember(owner: Symbol, name: Name): Symbol = { - getMemberIfDefined(owner, name) orElse { - if (phase.flatClasses && name.isTypeName && !owner.isPackageObjectOrClass) { - val pkg = owner.owner - val flatname = nme.flattenedName(owner.name, name) - getMember(pkg, flatname) - } - else fatalMissingSymbol(owner, name) - } - } - def getMemberValue(owner: Symbol, name: Name): TermSymbol = { - getMember(owner, name.toTermName) match { - case x: TermSymbol => x - case _ => fatalMissingSymbol(owner, name, "member value") - } - } - def getMemberModule(owner: Symbol, name: Name): ModuleSymbol = { - getMember(owner, name.toTermName) match { - case x: ModuleSymbol => x - case _ => fatalMissingSymbol(owner, name, "member object") - } - } - def getTypeMember(owner: Symbol, name: Name): TypeSymbol = { - getMember(owner, name.toTypeName) match { - case x: TypeSymbol => x - case _ => fatalMissingSymbol(owner, name, "type member") - } - } - def getMemberClass(owner: Symbol, name: Name): ClassSymbol = { - val y = getMember(owner, name.toTypeName) - getMember(owner, name.toTypeName) match { - case x: ClassSymbol => x - case _ => fatalMissingSymbol(owner, name, "member class") - } - } - def requiredMethod(owner: Symbol, name: Name): TermSymbol = { - getMember(owner, name.toTermName) match { - // todo. member symbol becomes a term symbol in cleanup. is this a bug? - // case x: MethodSymbol => x - case x: TermSymbol => x - case _ => fatalMissingSymbol(owner, name, "method") - } - } - - def getMemberIfDefined(owner: Symbol, name: Name): Symbol = - owner.info.nonPrivateMember(name) - - /** Using getDecl rather than getMember may avoid issues with - * OverloadedTypes turning up when you don't want them, if you - * know the method in question is uniquely declared in the given owner. - */ - def getDecl(owner: Symbol, name: Name): Symbol = { - getDeclIfDefined(owner, name) orElse fatalMissingSymbol(owner, name, "decl") - } - def getDeclIfDefined(owner: Symbol, name: Name): Symbol = - owner.info.nonPrivateDecl(name) - - def packageExists(packageName: String): Boolean = - getModuleIfDefined(packageName).isPackage - - private def newAlias(owner: Symbol, name: TypeName, alias: Type): AliasTypeSymbol = - owner.newAliasType(name) setInfoAndEnter alias - - 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)) - - clazz setInfo GenPolyType(List(tparam), ClassInfoType(parents, newScope, clazz)) - } - - def newPolyMethod(typeParamCount: Int, owner: Symbol, name: TermName, flags: Long)(createFn: PolyMethodCreator): MethodSymbol = { - val msym = owner.newMethod(name.encode, NoPosition, flags) - val tparams = msym.newSyntheticTypeParams(typeParamCount) - val mtpe = createFn(tparams) match { - case (Some(formals), restpe) => MethodType(msym.newSyntheticValueParams(formals), restpe) - case (_, restpe) => NullaryMethodType(restpe) - } - - msym setInfoAndEnter genPolyType(tparams, mtpe) - } - - /** T1 means one type parameter. - */ - def newT1NullaryMethod(owner: Symbol, name: TermName, flags: Long)(createFn: Symbol => Type): MethodSymbol = { - newPolyMethod(1, owner, name, flags)(tparams => (None, createFn(tparams.head))) - } - def newT1NoParamsMethod(owner: Symbol, name: TermName, flags: Long)(createFn: Symbol => Type): MethodSymbol = { - newPolyMethod(1, owner, name, flags)(tparams => (Some(Nil), createFn(tparams.head))) - } - - lazy val boxedClassValues = boxedClass.values.toSet[Symbol] - lazy val isUnbox = unboxMethod.values.toSet[Symbol] - lazy val isBox = boxMethod.values.toSet[Symbol] - - /** Is symbol a phantom class for which no runtime representation exists? */ - lazy val isPhantomClass = Set[Symbol](AnyClass, AnyValClass, NullClass, NothingClass) - /** Lists core classes that don't have underlying bytecode, but are synthesized on-the-fly in every reflection universe */ - lazy val syntheticCoreClasses = List( - AnnotationDefaultAttr, // #2264 - RepeatedParamClass, - JavaRepeatedParamClass, - ByNameParamClass, - AnyClass, - AnyRefClass, - AnyValClass, - NullClass, - NothingClass, - SingletonClass, - EqualsPatternClass - ) - /** Lists core methods that don't have underlying bytecode, but are synthesized on-the-fly in every reflection universe */ - lazy val syntheticCoreMethods = List( - Any_==, - Any_!=, - Any_equals, - Any_hashCode, - Any_toString, - Any_getClass, - Any_isInstanceOf, - Any_asInstanceOf, - Any_##, - Object_eq, - Object_ne, - Object_==, - Object_!=, - Object_##, - Object_synchronized, - Object_isInstanceOf, - Object_asInstanceOf, - String_+ - ) - /** Lists core classes that do have underlying bytecode, but are adjusted on-the-fly in every reflection universe */ - lazy val hijackedCoreClasses = List( - ComparableClass, - JavaSerializableClass - ) - /** Lists symbols that are synthesized or hijacked by the compiler. - * - * Such symbols either don't have any underlying bytecode at all ("synthesized") - * or get loaded from bytecode but have their metadata adjusted ("hijacked"). - */ - lazy val symbolsNotPresentInBytecode = syntheticCoreClasses ++ syntheticCoreMethods ++ hijackedCoreClasses - - /** Is the symbol that of a parent which is added during parsing? */ - lazy val isPossibleSyntheticParent = ProductClass.toSet[Symbol] + ProductRootClass + SerializableClass - - private lazy val boxedValueClassesSet = boxedClass.values.toSet[Symbol] + BoxedUnitClass - - /** Is symbol a value class? */ - def isPrimitiveValueClass(sym: Symbol) = ScalaValueClasses contains sym - def isNonUnitValueClass(sym: Symbol) = isPrimitiveValueClass(sym) && (sym != UnitClass) - def isSpecializableClass(sym: Symbol) = isPrimitiveValueClass(sym) || (sym == AnyRefClass) - def isPrimitiveValueType(tp: Type) = isPrimitiveValueClass(tp.typeSymbol) - - /** Is symbol a boxed value class, e.g. java.lang.Integer? */ - def isBoxedValueClass(sym: Symbol) = boxedValueClassesSet(sym) - - /** If symbol is a value class (boxed or not), return the unboxed - * value class. Otherwise, NoSymbol. - */ - def unboxedValueClass(sym: Symbol): Symbol = - if (isPrimitiveValueClass(sym)) sym - else if (sym == BoxedUnitClass) UnitClass - else boxedClass.map(kvp => (kvp._2: Symbol, kvp._1)).getOrElse(sym, NoSymbol) - - /** Is type's symbol a numeric value class? */ - def isNumericValueType(tp: Type): Boolean = tp match { - case TypeRef(_, sym, _) => isNumericValueClass(sym) - case _ => false - } - - // todo: reconcile with javaSignature!!! - def signature(tp: Type): String = { - def erasure(tp: Type): Type = tp match { - case st: SubType => erasure(st.supertype) - case RefinedType(parents, _) => erasure(parents.head) - case _ => tp - } - def flatNameString(sym: Symbol, separator: Char): String = - if (sym == NoSymbol) "" // be more resistant to error conditions, e.g. neg/t3222.scala - else if (sym.owner.isPackageClass) sym.javaClassName - else flatNameString(sym.owner, separator) + nme.NAME_JOIN_STRING + sym.simpleName - def signature1(etp: Type): String = { - if (etp.typeSymbol == ArrayClass) "[" + signature1(erasure(etp.normalize.typeArgs.head)) - else if (isPrimitiveValueClass(etp.typeSymbol)) abbrvTag(etp.typeSymbol).toString() - else "L" + flatNameString(etp.typeSymbol, '/') + ";" - } - val etp = erasure(tp) - if (etp.typeSymbol == ArrayClass) signature1(etp) - else flatNameString(etp.typeSymbol, '.') - } - - /** Surgery on the value classes. Without this, AnyVals defined in source - * files end up with an AnyRef parent. It is likely there is a better way - * to evade that AnyRef. - */ - private def setParents(sym: Symbol, parents: List[Type]): Symbol = sym.rawInfo match { - case ClassInfoType(_, scope, clazz) => - sym setInfo ClassInfoType(parents, scope, clazz) - case _ => - sym - } - - def init() { - if (isInitialized) return - // force initialization of every symbol that is synthesized or hijacked by the compiler - val forced = symbolsNotPresentInBytecode - isInitialized = true - } //init - - var nbScalaCallers: Int = 0 - def newScalaCaller(delegateType: Type): MethodSymbol = { - assert(forMSIL, "scalaCallers can only be created if target is .NET") - // object: reference to object on which to call (scala-)method - val paramTypes: List[Type] = List(ObjectClass.tpe) - val name = newTermName("$scalaCaller$$" + nbScalaCallers) - // tparam => resultType, which is the resultType of PolyType, i.e. the result type after applying the - // type parameter =-> a MethodType in this case - // TODO: set type bounds manually (-> MulticastDelegate), see newTypeParam - val newCaller = enterNewMethod(DelegateClass, name, paramTypes, delegateType, Final | STATIC) - // val newCaller = newPolyMethod(DelegateClass, name, - // tparam => MethodType(paramTypes, tparam.typeRef)) setFlag (Final | STATIC) - Delegate_scalaCallers = Delegate_scalaCallers ::: List(newCaller) - nbScalaCallers += 1 - newCaller - } - - // def addScalaCallerInfo(scalaCaller: Symbol, methSym: Symbol, delType: Type) { - // assert(Delegate_scalaCallers contains scalaCaller) - // Delegate_scalaCallerInfos += (scalaCaller -> (methSym, delType)) - // } - - def addScalaCallerInfo(scalaCaller: Symbol, methSym: Symbol) { - assert(Delegate_scalaCallers contains scalaCaller) - Delegate_scalaCallerTargets += (scalaCaller -> methSym) - } } } -*/ -- cgit v1.2.3