diff options
Diffstat (limited to 'src/dotty')
23 files changed, 487 insertions, 351 deletions
diff --git a/src/dotty/tools/backend/jvm/DottyBackendInterface.scala b/src/dotty/tools/backend/jvm/DottyBackendInterface.scala index f92abe906..6c737f58f 100644 --- a/src/dotty/tools/backend/jvm/DottyBackendInterface.scala +++ b/src/dotty/tools/backend/jvm/DottyBackendInterface.scala @@ -99,9 +99,6 @@ class DottyBackendInterface()(implicit ctx: Context) extends BackendInterface{ val nme_PACKAGE: Name = StdNames.nme.PACKAGE val nme_EQEQ_LOCAL_VAR: Name = StdNames.nme.EQEQ_LOCAL_VAR - val BoxesRunTimeModule = ctx.requiredModule("scala.runtime.BoxesRunTime") - val BoxesRunTimeClass = toDenot(BoxesRunTimeModule).moduleClass.asClass - // require LambdaMetafactory: scalac uses getClassIfDefined, but we need those always. override lazy val LambdaMetaFactory = ctx.requiredClass("java.lang.invoke.LambdaMetafactory") override lazy val MethodHandle = ctx.requiredClass("java.lang.invoke.MethodHandle") @@ -133,17 +130,17 @@ class DottyBackendInterface()(implicit ctx: Context) extends BackendInterface{ } val hashMethodSym: Symbol = NoSymbol // used to dispatch ## on primitives to ScalaRuntime.hash. Should be implemented by a miniphase - val externalEqualsNumNum: Symbol = ctx.requiredMethod(BoxesRunTimeClass, nme.equalsNumNum) - lazy val externalEqualsNumChar: Symbol = ??? // ctx.requiredMethod(BoxesRunTimeClass, nme.equalsNumChar) // this method is private - val externalEqualsNumObject: Symbol = ctx.requiredMethod(BoxesRunTimeClass, nme.equalsNumObject) - val externalEquals: Symbol = BoxesRunTimeClass.info.decl(nme.equals_).suchThat(toDenot(_).info.firstParamTypes.size == 2).symbol + val externalEqualsNumNum: Symbol = ctx.requiredMethod(defn.BoxesRunTimeModuleRef, nme.equalsNumNum) + lazy val externalEqualsNumChar: Symbol = ??? // ctx.requiredMethod(BoxesRunTimeTypeRef, nme.equalsNumChar) // this method is private + val externalEqualsNumObject: Symbol = ctx.requiredMethod(defn.BoxesRunTimeModuleRef, nme.equalsNumObject) + val externalEquals: Symbol = defn.BoxesRunTimeClass.info.decl(nme.equals_).suchThat(toDenot(_).info.firstParamTypes.size == 2).symbol val MaxFunctionArity: Int = Definitions.MaxFunctionArity val FunctionClass: Array[Symbol] = defn.FunctionClass.asInstanceOf[Array[Symbol]] val AbstractFunctionClass: Array[Symbol] = defn.AbstractFunctionClass.asInstanceOf[Array[Symbol]] val PartialFunctionClass: Symbol = defn.PartialFunctionClass val AbstractPartialFunctionClass: Symbol = defn.AbstractPartialFunctionClass val String_valueOf: Symbol = defn.String_valueOf_Object - lazy val Predef_classOf: Symbol = ctx.requiredMethod(toDenot(defn.ScalaPredefModule).moduleClass.asClass, nme.classOf) + lazy val Predef_classOf: Symbol = ctx.requiredMethod(defn.ScalaPredefModuleRef, nme.classOf) lazy val AnnotationRetentionAttr = ctx.requiredClass("java.lang.annotation.Retention") lazy val AnnotationRetentionSourceAttr = ctx.requiredClass("java.lang.annotation.RetentionPolicy").linkedClass.requiredValue("SOURCE") diff --git a/src/dotty/tools/backend/jvm/scalaPrimitives.scala b/src/dotty/tools/backend/jvm/scalaPrimitives.scala index 8e742faf1..afcf06da1 100644 --- a/src/dotty/tools/backend/jvm/scalaPrimitives.scala +++ b/src/dotty/tools/backend/jvm/scalaPrimitives.scala @@ -78,42 +78,42 @@ class DottyPrimitives(ctx: Context) { code match { - case APPLY => - elementType.classSymbol match { - case defn.BooleanClass => ZARRAY_GET - case defn.ByteClass => BARRAY_GET - case defn.ShortClass => SARRAY_GET - case defn.CharClass => CARRAY_GET - case defn.IntClass => IARRAY_GET - case defn.LongClass => LARRAY_GET - case defn.FloatClass => FARRAY_GET - case defn.DoubleClass => DARRAY_GET + case APPLY => // ### unstable, use names? + elementType match { + case defn.BooleanTypeRef => ZARRAY_GET + case defn.ByteTypeRef => BARRAY_GET + case defn.ShortTypeRef => SARRAY_GET + case defn.CharTypeRef => CARRAY_GET + case defn.IntTypeRef => IARRAY_GET + case defn.LongTypeRef => LARRAY_GET + case defn.FloatTypeRef => FARRAY_GET + case defn.DoubleTypeRef => DARRAY_GET case _ => OARRAY_GET } case UPDATE => - elementType.classSymbol match { - case defn.BooleanClass => ZARRAY_SET - case defn.ByteClass => BARRAY_SET - case defn.ShortClass => SARRAY_SET - case defn.CharClass => CARRAY_SET - case defn.IntClass => IARRAY_SET - case defn.LongClass => LARRAY_SET - case defn.FloatClass => FARRAY_SET - case defn.DoubleClass => DARRAY_SET + elementType match { + case defn.BooleanTypeRef => ZARRAY_SET + case defn.ByteTypeRef => BARRAY_SET + case defn.ShortTypeRef => SARRAY_SET + case defn.CharTypeRef => CARRAY_SET + case defn.IntTypeRef => IARRAY_SET + case defn.LongTypeRef => LARRAY_SET + case defn.FloatTypeRef => FARRAY_SET + case defn.DoubleTypeRef => DARRAY_SET case _ => OARRAY_SET } case LENGTH => - elementType.classSymbol match { - case defn.BooleanClass => ZARRAY_LENGTH - case defn.ByteClass => BARRAY_LENGTH - case defn.ShortClass => SARRAY_LENGTH - case defn.CharClass => CARRAY_LENGTH - case defn.IntClass => IARRAY_LENGTH - case defn.LongClass => LARRAY_LENGTH - case defn.FloatClass => FARRAY_LENGTH - case defn.DoubleClass => DARRAY_LENGTH + elementType match { + case defn.BooleanTypeRef => ZARRAY_LENGTH + case defn.ByteTypeRef => BARRAY_LENGTH + case defn.ShortTypeRef => SARRAY_LENGTH + case defn.CharTypeRef => CARRAY_LENGTH + case defn.IntTypeRef => IARRAY_LENGTH + case defn.LongTypeRef => LARRAY_LENGTH + case defn.FloatTypeRef => FARRAY_LENGTH + case defn.DoubleTypeRef => DARRAY_LENGTH case _ => OARRAY_LENGTH } diff --git a/src/dotty/tools/dotc/Compiler.scala b/src/dotty/tools/dotc/Compiler.scala index bf3dbb232..4e96a6c8a 100644 --- a/src/dotty/tools/dotc/Compiler.scala +++ b/src/dotty/tools/dotc/Compiler.scala @@ -5,6 +5,7 @@ import core._ import Contexts._ import Periods._ import Symbols._ +import Types._ import Scopes._ import typer.{FrontEnd, Typer, Mode, ImportInfo, RefChecks} import reporting.{Reporter, ConsoleReporter} @@ -111,8 +112,8 @@ class Compiler { .setMode(Mode.ImplicitsEnabled) .setTyperState(new MutableTyperState(ctx.typerState, rootReporter(ctx), isCommittable = true)) ctx.definitions.init(start) // set context of definitions to start - def addImport(ctx: Context, symf: () => Symbol) = - ctx.fresh.setImportInfo(ImportInfo.rootImport(symf)(ctx)) + def addImport(ctx: Context, refFn: () => TermRef) = + ctx.fresh.setImportInfo(ImportInfo.rootImport(refFn)(ctx)) (start.setRunInfo(new RunInfo(start)) /: defn.RootImportFns)(addImport) } diff --git a/src/dotty/tools/dotc/ast/Desugar.scala b/src/dotty/tools/dotc/ast/Desugar.scala index 33205dfd4..ad34533aa 100644 --- a/src/dotty/tools/dotc/ast/Desugar.scala +++ b/src/dotty/tools/dotc/ast/Desugar.scala @@ -323,7 +323,7 @@ object desugar { def anyRef = ref(defn.AnyRefAlias.typeRef) def productConstr(n: Int) = { - val tycon = ref(defn.ProductNClass(n).typeRef) + val tycon = ref(defn.ProductNTypeRef(n)) val targs = constrVparamss.head map (_.tpt) if (targs.isEmpty) tycon else AppliedTypeTree(tycon, targs) } @@ -825,15 +825,15 @@ object desugar { } else { val arity = ts.length - def tupleClass = defn.TupleClass(arity) + def tupleTypeRef = defn.TupleTypeRef(arity) if (arity > Definitions.MaxTupleArity) { ctx.error(s"tuple too long (max allowed: ${Definitions.MaxTupleArity})", tree.pos) unitLiteral } else if (arity == 1) ts.head - else if (ctx.mode is Mode.Type) AppliedTypeTree(ref(tupleClass.typeRef), ts) + else if (ctx.mode is Mode.Type) AppliedTypeTree(ref(tupleTypeRef), ts) else if (arity == 0) unitLiteral - else Apply(ref(tupleClass.companionModule.valRef), ts) + else Apply(ref(tupleTypeRef.classSymbol.companionModule.valRef), ts) } case WhileDo(cond, body) => // { <label> def while$(): Unit = if (cond) { body; while$() } ; while$() } diff --git a/src/dotty/tools/dotc/ast/tpd.scala b/src/dotty/tools/dotc/ast/tpd.scala index 14a36f398..5bc22418b 100644 --- a/src/dotty/tools/dotc/ast/tpd.scala +++ b/src/dotty/tools/dotc/ast/tpd.scala @@ -778,6 +778,27 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo { } else Assign(tree, rhs) + /** A tree in place of this tree that represents the class of type `tp`. + * Contains special handling if the class is a primitive value class + * and invokes a `default` method otherwise. + */ + def clsOf(tp: Type, default: => Tree)(implicit ctx: Context): Tree = { + def TYPE(module: TermSymbol) = + ref(module).select(nme.TYPE_).ensureConforms(tree.tpe).withPos(tree.pos) + defn.scalaClassName(tp) match { + case tpnme.Boolean => TYPE(defn.BoxedBooleanModule) + case tpnme.Byte => TYPE(defn.BoxedByteModule) + case tpnme.Short => TYPE(defn.BoxedShortModule) + case tpnme.Char => TYPE(defn.BoxedCharModule) + case tpnme.Int => TYPE(defn.BoxedIntModule) + case tpnme.Long => TYPE(defn.BoxedLongModule) + case tpnme.Float => TYPE(defn.BoxedFloatModule) + case tpnme.Double => TYPE(defn.BoxedDoubleModule) + case tpnme.Unit => TYPE(defn.BoxedVoidModule) + case _ => default + } + } + // --- Higher order traversal methods ------------------------------- /** Apply `f` to each subtree of this tree */ diff --git a/src/dotty/tools/dotc/core/Definitions.scala b/src/dotty/tools/dotc/core/Definitions.scala index 6f322904e..fc025380d 100644 --- a/src/dotty/tools/dotc/core/Definitions.scala +++ b/src/dotty/tools/dotc/core/Definitions.scala @@ -82,9 +82,9 @@ class Definitions { private def newT1EmptyParamsMethod(cls: ClassSymbol, name: TermName, resultTypeFn: PolyType => Type, flags: FlagSet) = newPolyMethod(cls, name, 1, pt => MethodType(Nil, resultTypeFn(pt)), flags) - private def mkArityArray(name: String, arity: Int, countFrom: Int): Array[ClassSymbol] = { - val arr = new Array[ClassSymbol](arity + 1) - for (i <- countFrom to arity) arr(i) = ctx.requiredClass(name + i) + private def mkArityArray(name: String, arity: Int, countFrom: Int): Array[TypeRef] = { + val arr = new Array[TypeRef](arity + 1) + for (i <- countFrom to arity) arr(i) = ctx.requiredClassRef(name + i) arr } @@ -114,7 +114,8 @@ class Definitions { lazy val JavaLangPackageVal = ctx.requiredPackage("java.lang") // fundamental modules lazy val SysPackage = ctx.requiredModule("scala.sys.package") - def Sys_error = ctx.requiredMethod(SysPackage.moduleClass.asClass, nme.error) + lazy val Sys_errorR = ctx.requiredMethodRef(SysPackage.moduleClass.typeRef, nme.error) + def Sys_error = Sys_errorR.symbol /** Note: We cannot have same named methods defined in Object and Any (and AnyVal, for that matter) * because after erasure the Any and AnyVal references get remapped to the Object methods @@ -160,6 +161,7 @@ class Definitions { cls.info = ClassInfo(cls.owner.thisType, cls, AnyClass.typeRef :: Nil, newScope) completeClass(cls) } + lazy val AnyRefAlias: TypeSymbol = newAliasType(tpnme.AnyRef, ObjectType) lazy val Object_eq = newMethod(ObjectClass, nme.eq, methOfAnyRef(BooleanType), Final) @@ -190,29 +192,41 @@ class Definitions { ScalaPackageClass, tpnme.Nothing, AbstractFinal, List(AnyClass.typeRef)) lazy val NullClass: ClassSymbol = newCompleteClassSymbol( ScalaPackageClass, tpnme.Null, AbstractFinal, List(ObjectClass.typeRef)) + lazy val NullTypeRef = NullClass.typeRef - lazy val ScalaPredefModule = ctx.requiredModule("scala.Predef") + lazy val ScalaPredefModuleRef = ctx.requiredModuleRef("scala.Predef") + def ScalaPredefModule = ScalaPredefModuleRef.symbol - lazy val Predef_conforms = ctx.requiredMethod(ScalaPredefModule.moduleClass.asClass, "$conforms") + lazy val Predef_conformsR = ctx.requiredMethodRef(ScalaPredefModuleRef, "$conforms") + def Predef_conforms = Predef_conformsR.symbol - lazy val ScalaRuntimeModule = ctx.requiredModule("scala.runtime.ScalaRunTime") - lazy val ScalaRuntimeClass = ScalaRuntimeModule.moduleClass.asClass + lazy val ScalaRuntimeModuleRef = ctx.requiredModuleRef("scala.runtime.ScalaRunTime") + def ScalaRuntimeModule = ScalaRuntimeModuleRef.symbol + def ScalaRuntimeClass = ScalaRuntimeModule.moduleClass.asClass - def runtimeMethod(name: PreName) = ctx.requiredMethod(ScalaRuntimeClass, name) + def runtimeMethodRef(name: PreName) = ctx.requiredMethodRef(ScalaRuntimeModuleRef, name) + def ScalaRuntime_dropR = runtimeMethodRef(nme.drop) + def ScalaRuntime_drop = ScalaRuntime_dropR.symbol - lazy val BoxesRunTimeModule = ctx.requiredModule("scala.runtime.BoxesRunTime") - lazy val BoxesRunTimeClass = BoxesRunTimeModule.moduleClass.asClass - lazy val ScalaStaticsModule = ctx.requiredModule("scala.runtime.Statics") - lazy val ScalaStaticsClass = ScalaStaticsModule.moduleClass.asClass + lazy val BoxesRunTimeModuleRef = ctx.requiredModuleRef("scala.runtime.BoxesRunTime") + def BoxesRunTimeModule = BoxesRunTimeModuleRef.symbol + def BoxesRunTimeClass = BoxesRunTimeModule.moduleClass.asClass + lazy val ScalaStaticsModuleRef = ctx.requiredModuleRef("scala.runtime.Statics") + def ScalaStaticsModule = ScalaStaticsModuleRef.symbol + def ScalaStaticsClass = ScalaStaticsModule.moduleClass.asClass - def staticsMethod(name: PreName) = ctx.requiredMethod(ScalaStaticsClass, name) + def staticsMethodRef(name: PreName) = ctx.requiredMethodRef(ScalaStaticsModuleRef, name) + def staticsMethod(name: PreName) = ctx.requiredMethod(ScalaStaticsModuleRef, name) - lazy val DottyPredefModule = ctx.requiredModule("dotty.DottyPredef") - lazy val DottyArraysModule = ctx.requiredModule("dotty.runtime.Arrays") + lazy val DottyPredefModuleRef = ctx.requiredModuleRef("dotty.DottyPredef") + def DottyPredefModule = DottyPredefModuleRef.symbol + lazy val DottyArraysModuleRef = ctx.requiredModuleRef("dotty.runtime.Arrays") + def DottyArraysModule = DottyArraysModuleRef.symbol - def newRefArrayMethod = ctx.requiredMethod(DottyArraysModule.moduleClass.asClass, "newRefArray") + def newRefArrayMethod = ctx.requiredMethod(DottyArraysModuleRef, "newRefArray") - lazy val NilModule = ctx.requiredModule("scala.collection.immutable.Nil") + lazy val NilModuleRef = ctx.requiredModuleRef("scala.collection.immutable.Nil") + def NilModule = NilModuleRef.symbol // lazy val FunctionClass: ClassSymbol = ctx.requiredClass("scala.Function") lazy val SingletonClass: ClassSymbol = @@ -221,57 +235,96 @@ class Definitions { newCompleteClassSymbol( ScalaPackageClass, tpnme.Singleton, PureInterfaceCreationFlags | Final, List(AnyClass.typeRef), EmptyScope) - lazy val SeqClass: ClassSymbol = ctx.requiredClass("scala.collection.Seq") - lazy val Seq_apply = ctx.requiredMethod(SeqClass, nme.apply) - lazy val Seq_head = ctx.requiredMethod(SeqClass, nme.head) - lazy val ArrayClass: ClassSymbol = ctx.requiredClass("scala.Array") - lazy val Array_apply = ctx.requiredMethod(ArrayClass, nme.apply) - lazy val Array_update = ctx.requiredMethod(ArrayClass, nme.update) - lazy val Array_length = ctx.requiredMethod(ArrayClass, nme.length) - lazy val Array_clone = ctx.requiredMethod(ArrayClass, nme.clone_) - lazy val ArrayConstructor = ctx.requiredMethod(ArrayClass, nme.CONSTRUCTOR) - lazy val traversableDropMethod = ctx.requiredMethod(ScalaRuntimeClass, nme.drop) - 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) - lazy val Boolean_! = BooleanClass.requiredMethod(nme.UNARY_!) - lazy val Boolean_&& = BooleanClass.requiredMethod(nme.ZAND) - lazy val Boolean_|| = BooleanClass.requiredMethod(nme.ZOR) - - lazy val ByteClass = valueClassSymbol("scala.Byte", BoxedByteClass, java.lang.Byte.TYPE, ByteEnc) - lazy val ShortClass = valueClassSymbol("scala.Short", BoxedShortClass, java.lang.Short.TYPE, ShortEnc) - lazy val CharClass = valueClassSymbol("scala.Char", BoxedCharClass, java.lang.Character.TYPE, CharEnc) - lazy val IntClass = valueClassSymbol("scala.Int", BoxedIntClass, java.lang.Integer.TYPE, IntEnc) - lazy val Int_- = IntClass.requiredMethod(nme.MINUS, List(IntType)) - lazy val Int_+ = IntClass.requiredMethod(nme.PLUS, List(IntType)) - lazy val Int_/ = IntClass.requiredMethod(nme.DIV, List(IntType)) - lazy val Int_* = IntClass.requiredMethod(nme.MUL, List(IntType)) - lazy val Int_== = IntClass.requiredMethod(nme.EQ, List(IntType)) - lazy val Int_>= = IntClass.requiredMethod(nme.GE, List(IntType)) - lazy val Int_<= = IntClass.requiredMethod(nme.LE, List(IntType)) - lazy val LongClass = valueClassSymbol("scala.Long", BoxedLongClass, java.lang.Long.TYPE, LongEnc) - lazy val Long_XOR_Long = LongClass.info.member(nme.XOR).requiredSymbol( + + lazy val SeqTypeRef = ctx.requiredClassRef("scala.collection.Seq") + def SeqClass = SeqTypeRef.symbol.asClass + lazy val Seq_applyR = ctx.requiredMethodRef(SeqTypeRef, nme.apply) + def Seq_apply = Seq_applyR.symbol + lazy val Seq_headR = ctx.requiredMethodRef(SeqTypeRef, nme.head) + def Seq_head = Seq_headR.symbol + + lazy val ArrayTypeRef = ctx.requiredClassRef("scala.Array") + def ArrayClass = ArrayTypeRef.symbol.asClass + lazy val Array_applyR = ctx.requiredMethodRef(ArrayTypeRef, nme.apply) + def Array_apply = Array_applyR.symbol + lazy val Array_updateR = ctx.requiredMethodRef(ArrayTypeRef, nme.update) + def Array_update = Array_updateR.symbol + lazy val Array_lengthR = ctx.requiredMethodRef(ArrayTypeRef, nme.length) + def Array_length = Array_lengthR.symbol + lazy val Array_cloneR = ctx.requiredMethodRef(ArrayTypeRef, nme.clone_) + def Array_clone = Array_cloneR.symbol + lazy val ArrayConstructorR = ctx.requiredMethodRef(ArrayTypeRef, nme.CONSTRUCTOR) + def ArrayConstructor = ArrayConstructorR.symbol + + lazy val uncheckedStableClassRef: TypeRef = ctx.requiredClassRef("scala.annotation.unchecked.uncheckedStable") // ### roll into annotations + + lazy val UnitTypeRef = valueTypeRef("scala.Unit", BoxedUnitTypeRef, java.lang.Void.TYPE, UnitEnc) + def UnitClass = UnitTypeRef.symbol.asClass + lazy val BooleanTypeRef = valueTypeRef("scala.Boolean", BoxedBooleanTypeRef, java.lang.Boolean.TYPE, BooleanEnc) + def BooleanClass = BooleanTypeRef.symbol.asClass + lazy val Boolean_notR = BooleanTypeRef.symbol.requiredMethodRef(nme.UNARY_!) + def Boolean_! = Boolean_notR.symbol + lazy val Boolean_andR = BooleanTypeRef.symbol.requiredMethodRef(nme.ZAND) // ### harmonize required... calls + def Boolean_&& = Boolean_andR.symbol + lazy val Boolean_orR = BooleanTypeRef.symbol.requiredMethodRef(nme.ZOR) + def Boolean_|| = Boolean_orR.symbol + + lazy val ByteTypeRef = valueTypeRef("scala.Byte", BoxedByteTypeRef, java.lang.Byte.TYPE, ByteEnc) + def ByteClass = ByteTypeRef.symbol.asClass + lazy val ShortTypeRef = valueTypeRef("scala.Short", BoxedShortTypeRef, java.lang.Short.TYPE, ShortEnc) + def ShortClass = ShortTypeRef.symbol.asClass + lazy val CharTypeRef = valueTypeRef("scala.Char", BoxedCharTypeRef, java.lang.Character.TYPE, CharEnc) + def CharClass = CharTypeRef.symbol.asClass + lazy val IntTypeRef = valueTypeRef("scala.Int", BoxedIntTypeRef, java.lang.Integer.TYPE, IntEnc) + def IntClass = IntTypeRef.symbol.asClass + lazy val Int_minusR = IntTypeRef.symbol.requiredMethodRef(nme.MINUS, List(IntType)) + def Int_- = Int_minusR.symbol + lazy val Int_plusR = IntTypeRef.symbol.requiredMethodRef(nme.PLUS, List(IntType)) + def Int_+ = Int_plusR.symbol + lazy val Int_divR = IntTypeRef.symbol.requiredMethodRef(nme.DIV, List(IntType)) + def Int_/ = Int_divR.symbol + lazy val Int_mulR = IntTypeRef.symbol.requiredMethodRef(nme.MUL, List(IntType)) + def Int_* = Int_mulR.symbol + lazy val Int_eqR = IntTypeRef.symbol.requiredMethodRef(nme.EQ, List(IntType)) + def Int_== = Int_eqR.symbol + lazy val Int_geR = IntTypeRef.symbol.requiredMethodRef(nme.GE, List(IntType)) + def Int_>= = Int_geR.symbol + lazy val Int_leR = IntTypeRef.symbol.requiredMethodRef(nme.LE, List(IntType)) + def Int_<= = Int_leR.symbol + lazy val LongTypeRef = valueTypeRef("scala.Long", BoxedLongTypeRef, java.lang.Long.TYPE, LongEnc) + def LongClass = LongTypeRef.symbol.asClass + lazy val Long_XOR_Long = LongTypeRef.member(nme.XOR).requiredSymbol( x => (x is Method) && (x.info.firstParamTypes.head isRef defn.LongClass) ) - lazy val Long_LSR_Int = LongClass.info.member(nme.LSR).requiredSymbol( + lazy val Long_LSR_Int = LongTypeRef.member(nme.LSR).requiredSymbol( x => (x is Method) && (x.info.firstParamTypes.head isRef defn.IntClass) ) - 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 = ctx.requiredClass("scala.runtime.BoxedUnit") - - lazy val BoxedUnit_UNIT = BoxedUnitClass.linkedClass.requiredValue("UNIT") - - 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 FloatTypeRef = valueTypeRef("scala.Float", BoxedFloatTypeRef, java.lang.Float.TYPE, FloatEnc) + def FloatClass = FloatTypeRef.symbol.asClass + lazy val DoubleTypeRef = valueTypeRef("scala.Double", BoxedDoubleTypeRef, java.lang.Double.TYPE, DoubleEnc) + def DoubleClass = DoubleTypeRef.symbol.asClass + + lazy val BoxedUnitTypeRef = ctx.requiredClassRef("scala.runtime.BoxedUnit") + def BoxedUnitClass = BoxedUnitTypeRef.symbol.asClass + + lazy val BoxedUnit_UNIT = BoxedUnitTypeRef.symbol.linkedClass.requiredValue("UNIT") // ### replace with BoxedUnitModule? + + lazy val BoxedBooleanTypeRef = ctx.requiredClassRef("java.lang.Boolean") + def BoxedBooleanClass = BoxedBooleanTypeRef.symbol.asClass + lazy val BoxedByteTypeRef = ctx.requiredClassRef("java.lang.Byte") + def BoxedByteClass = BoxedByteTypeRef.symbol.asClass + lazy val BoxedShortTypeRef = ctx.requiredClassRef("java.lang.Short") + def BoxedShortClass = BoxedShortTypeRef.symbol.asClass + lazy val BoxedCharTypeRef = ctx.requiredClassRef("java.lang.Character") + def BoxedCharClass = BoxedCharTypeRef.symbol.asClass + lazy val BoxedIntTypeRef = ctx.requiredClassRef("java.lang.Integer") + def BoxedIntClass = BoxedIntTypeRef.symbol.asClass + lazy val BoxedLongTypeRef = ctx.requiredClassRef("java.lang.Long") + def BoxedLongClass = BoxedLongTypeRef.symbol.asClass + lazy val BoxedFloatTypeRef = ctx.requiredClassRef("java.lang.Float") + def BoxedFloatClass = BoxedFloatTypeRef.symbol.asClass + lazy val BoxedDoubleTypeRef = ctx.requiredClassRef("java.lang.Double") + def BoxedDoubleClass = BoxedDoubleTypeRef.symbol.asClass lazy val BoxedBooleanModule = ctx.requiredModule("java.lang.Boolean") lazy val BoxedByteModule = ctx.requiredModule("java.lang.Byte") @@ -289,8 +342,8 @@ class Definitions { lazy val RepeatedParamClass = specialPolyClass(tpnme.REPEATED_PARAM_CLASS, Covariant, ObjectType, SeqType) // fundamental classes - lazy val StringClass = ctx.requiredClass("java.lang.String") - lazy val StringModule = StringClass.linkedClass + lazy val StringClass = ctx.requiredClass("java.lang.String") + lazy val StringModule = StringClass.linkedClass lazy val String_+ = newMethod(StringClass, nme.raw.PLUS, methOfAny(StringType), Final) lazy val String_valueOf_Object = StringModule.info.member(nme.valueOf).suchThat(_.info.firstParamTypes match { @@ -298,71 +351,117 @@ class Definitions { case _ => false }).symbol - // in scalac modified to have Any as parrent - - lazy val SerializableClass = ctx.requiredClass("scala.Serializable") lazy val JavaCloneableClass = ctx.requiredClass("java.lang.Cloneable") - lazy val StringBuilderClass = ctx.requiredClass("scala.collection.mutable.StringBuilder") - lazy val NullPointerExceptionClass = ctx.requiredClass(jnme.NPException) - lazy val MatchErrorClass = ctx.requiredClass("scala.MatchError") - lazy val MatchErrorType = MatchErrorClass.typeRef - - lazy val StringAddClass = ctx.requiredClass("scala.runtime.StringAdd") - - lazy val StringAdd_+ = StringAddClass.requiredMethod(nme.raw.PLUS) - - 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 ClassCastExceptionClass = ctx.requiredClass("java.lang.ClassCastException") - lazy val JavaSerializableClass = ctx.requiredClass("java.lang.Serializable") - lazy val ComparableClass = ctx.requiredClass("java.lang.Comparable") - lazy val ProductClass = ctx.requiredClass("scala.Product") - lazy val Product_canEqual = ProductClass.requiredMethod(nme.canEqual_) - lazy val Product_productArity = ProductClass.requiredMethod(nme.productArity) - lazy val Product_productPrefix = ProductClass.requiredMethod(nme.productPrefix) - lazy val LanguageModuleClass = ctx.requiredModule("dotty.language").moduleClass.asClass - lazy val NonLocalReturnControlClass = ctx.requiredClass("scala.runtime.NonLocalReturnControl") + lazy val NullPointerExceptionClass = ctx.requiredClass("java.lang.NullPointerException") + lazy val ClassClass = ctx.requiredClass("java.lang.Class") + lazy val BoxedNumberClass = ctx.requiredClass("java.lang.Number") + lazy val ThrowableClass = ctx.requiredClass("java.lang.Throwable") + lazy val ClassCastExceptionClass = ctx.requiredClass("java.lang.ClassCastException") + lazy val JavaSerializableClass = ctx.requiredClass("java.lang.Serializable") + lazy val ComparableClass = ctx.requiredClass("java.lang.Comparable") + + // in scalac modified to have Any as parent + + lazy val SerializableTypeRef = ctx.requiredClassRef("scala.Serializable") + def SerializableClass = SerializableTypeRef.symbol.asClass + lazy val StringBuilderTypeRef = ctx.requiredClassRef("scala.collection.mutable.StringBuilder") + def StringBuilderClass = StringBuilderTypeRef.symbol.asClass + lazy val MatchErrorTypeRef = ctx.requiredClassRef("scala.MatchError") + def MatchErrorClass = MatchErrorTypeRef.symbol.asClass + + lazy val StringAddTypeRef = ctx.requiredClassRef("scala.runtime.StringAdd") + def StringAddClass = StringAddTypeRef.symbol.asClass + + lazy val StringAdd_plusR = StringAddTypeRef.symbol.requiredMethodRef(nme.raw.PLUS) + def StringAdd_+ = StringAdd_plusR.symbol + + lazy val PairTypeRef = ctx.requiredClassRef("dotty.Pair") + def PairClass = PairTypeRef.symbol.asClass + lazy val PartialFunctionTypeRef = ctx.requiredClassRef("scala.PartialFunction") + def PartialFunctionClass = PartialFunctionTypeRef.symbol.asClass + lazy val AbstractPartialFunctionTypeRef = ctx.requiredClassRef("scala.runtime.AbstractPartialFunction") + def AbstractPartialFunctionClass = AbstractPartialFunctionTypeRef.symbol.asClass + lazy val SymbolTypeRef = ctx.requiredClassRef("scala.Symbol") + def SymbolClass = SymbolTypeRef.symbol.asClass + lazy val DynamicTypeRef = ctx.requiredClassRef("scala.Dynamic") + def DynamicClass = DynamicTypeRef.symbol.asClass + lazy val OptionTypeRef = ctx.requiredClassRef("scala.Option") + def OptionClass = OptionTypeRef.symbol.asClass + lazy val ProductTypeRef = ctx.requiredClassRef("scala.Product") + def ProductClass = ProductTypeRef.symbol.asClass + lazy val Product_canEqualR = ProductTypeRef.symbol.requiredMethodRef(nme.canEqual_) + def Product_canEqual = Product_canEqualR.symbol + lazy val Product_productArityR = ProductTypeRef.symbol.requiredMethod(nme.productArity) + def Product_productArity = Product_productArityR.symbol + lazy val Product_productPrefixR = ProductTypeRef.symbol.requiredMethod(nme.productPrefix) + def Product_productPrefix = Product_productPrefixR.symbol + lazy val LanguageModuleTypeRef = ctx.requiredModule("dotty.language").moduleClass.asClass + def LanguageModuleClass = LanguageModuleTypeRef.symbol.asClass // ### Needed? Maube just keep LanguageModule? + lazy val NonLocalReturnControlTypeRef = ctx.requiredClassRef("scala.runtime.NonLocalReturnControl") // Annotation base classes - lazy val AnnotationClass = ctx.requiredClass("scala.annotation.Annotation") - lazy val ClassfileAnnotationClass = ctx.requiredClass("scala.annotation.ClassfileAnnotation") - lazy val StaticAnnotationClass = ctx.requiredClass("scala.annotation.StaticAnnotation") - lazy val TailrecAnnotationClass = ctx.requiredClass("scala.annotation.tailrec") - lazy val RemoteAnnot = ctx.requiredClass("scala.remote") - lazy val SerialVersionUIDAnnot = ctx.requiredClass("scala.SerialVersionUID") - lazy val TransientAnnot = ctx.requiredClass("scala.transient") - lazy val NativeAnnot = ctx.requiredClass("scala.native") - lazy val ScalaStrictFPAnnot = ctx.requiredClass("scala.annotation.strictfp") + lazy val AnnotationTypeRef = ctx.requiredClassRef("scala.annotation.Annotation") // ### AnnotationTypeRef --> AnnotRef? + def AnnotationClass = AnnotationTypeRef.symbol.asClass + lazy val ClassfileAnnotationTypeRef = ctx.requiredClassRef("scala.annotation.ClassfileAnnotation") + def ClassfileAnnotationClass = ClassfileAnnotationTypeRef.symbol.asClass + lazy val StaticAnnotationTypeRef = ctx.requiredClassRef("scala.annotation.StaticAnnotation") + def StaticAnnotationClass = StaticAnnotationTypeRef.symbol.asClass + lazy val TailrecAnnotationTypeRef = ctx.requiredClassRef("scala.annotation.tailrec") + def TailrecAnnotationClass = TailrecAnnotationTypeRef.symbol.asClass + lazy val RemoteAnnotRef = ctx.requiredClassRef("scala.remote") + def RemoteAnnot = RemoteAnnotRef.symbol.asClass + lazy val SerialVersionUIDAnnotRef = ctx.requiredClassRef("scala.SerialVersionUID") + def SerialVersionUIDAnnot = SerialVersionUIDAnnotRef.symbol.asClass + lazy val TransientAnnotRef = ctx.requiredClassRef("scala.transient") + def TransientAnnot = TransientAnnotRef.symbol.asClass + lazy val NativeAnnotRef = ctx.requiredClassRef("scala.native") + def NativeAnnot = NativeAnnotRef.symbol.asClass + lazy val ScalaStrictFPAnnotRef = ctx.requiredClassRef("scala.annotation.strictfp") + def ScalaStrictFPAnnot = ScalaStrictFPAnnotRef.symbol.asClass // Annotation classes - lazy val AliasAnnot = ctx.requiredClass("dotty.annotation.internal.Alias") - lazy val ChildAnnot = ctx.requiredClass("dotty.annotation.internal.Child") - lazy val RepeatedAnnot = ctx.requiredClass("dotty.annotation.internal.Repeated") - 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 TASTYSignatureAnnot = ctx.requiredClass("scala.annotation.internal.TASTYSignature") - lazy val TASTYLongSignatureAnnot = ctx.requiredClass("scala.annotation.internal.TASTYLongSignature") - lazy val DeprecatedAnnot = ctx.requiredClass("scala.deprecated") - lazy val MigrationAnnot = ctx.requiredClass("scala.annotation.migration") - lazy val AnnotationDefaultAnnot = ctx.requiredClass("dotty.annotation.internal.AnnotationDefault") - lazy val ThrowsAnnot = ctx.requiredClass("scala.throws") - lazy val UncheckedAnnot = ctx.requiredClass("scala.unchecked") - lazy val UncheckedStableAnnot = ctx.requiredClass("scala.annotation.unchecked.uncheckedStable") - lazy val UncheckedVarianceAnnot = ctx.requiredClass("scala.annotation.unchecked.uncheckedVariance") - lazy val VolatileAnnot = ctx.requiredClass("scala.volatile") - lazy val FieldMetaAnnot = ctx.requiredClass("scala.annotation.meta.field") - lazy val GetterMetaAnnot = ctx.requiredClass("scala.annotation.meta.getter") - lazy val SetterMetaAnnot = ctx.requiredClass("scala.annotation.meta.setter") + lazy val AliasAnnotRef = ctx.requiredClassRef("dotty.annotation.internal.Alias") + def AliasAnnot = AliasAnnotRef.symbol.asClass + lazy val ChildAnnotRef = ctx.requiredClassRef("dotty.annotation.internal.Child") + def ChildAnnot = ChildAnnotRef.symbol.asClass + lazy val RepeatedAnnotRef = ctx.requiredClassRef("dotty.annotation.internal.Repeated") + def RepeatedAnnot = RepeatedAnnotRef.symbol.asClass + lazy val InvariantBetweenAnnotRef = ctx.requiredClassRef("dotty.annotation.internal.InvariantBetween") + def InvariantBetweenAnnot = InvariantBetweenAnnotRef.symbol.asClass + lazy val CovariantBetweenAnnotRef = ctx.requiredClassRef("dotty.annotation.internal.CovariantBetween") + def CovariantBetweenAnnot = CovariantBetweenAnnotRef.symbol.asClass + lazy val ContravariantBetweenAnnotRef = ctx.requiredClassRef("dotty.annotation.internal.ContravariantBetween") + def ContravariantBetweenAnnot = ContravariantBetweenAnnotRef.symbol.asClass + lazy val ScalaSignatureAnnotRef = ctx.requiredClassRef("scala.reflect.ScalaSignature") + def ScalaSignatureAnnot = ScalaSignatureAnnotRef.symbol.asClass + lazy val ScalaLongSignatureAnnotRef = ctx.requiredClassRef("scala.reflect.ScalaLongSignature") + def ScalaLongSignatureAnnot = ScalaLongSignatureAnnotRef.symbol.asClass + lazy val TASTYSignatureAnnotRef = ctx.requiredClassRef("scala.annotation.internal.TASTYSignature") + def TASTYSignatureAnnot = TASTYSignatureAnnotRef.symbol.asClass + lazy val TASTYLongSignatureAnnotRef = ctx.requiredClassRef("scala.annotation.internal.TASTYLongSignature") + def TASTYLongSignatureAnnot = TASTYLongSignatureAnnotRef.symbol.asClass + lazy val DeprecatedAnnotRef = ctx.requiredClassRef("scala.deprecated") + def DeprecatedAnnot = DeprecatedAnnotRef.symbol.asClass + lazy val MigrationAnnotRef = ctx.requiredClassRef("scala.annotation.migration") + def MigrationAnnot = MigrationAnnotRef.symbol.asClass + lazy val AnnotationDefaultAnnotRef = ctx.requiredClassRef("dotty.annotation.internal.AnnotationDefault") + def AnnotationDefaultAnnot = AnnotationDefaultAnnotRef.symbol.asClass + lazy val ThrowsAnnotRef = ctx.requiredClassRef("scala.throws") + def ThrowsAnnot = ThrowsAnnotRef.symbol.asClass + lazy val UncheckedAnnotRef = ctx.requiredClassRef("scala.unchecked") + def UncheckedAnnot = UncheckedAnnotRef.symbol.asClass + lazy val UncheckedStableAnnotRef = ctx.requiredClassRef("scala.annotation.unchecked.uncheckedStable") + def UncheckedStableAnnot = UncheckedStableAnnotRef.symbol.asClass + lazy val UncheckedVarianceAnnotRef = ctx.requiredClassRef("scala.annotation.unchecked.uncheckedVariance") + def UncheckedVarianceAnnot = UncheckedVarianceAnnotRef.symbol.asClass + lazy val VolatileAnnotRef = ctx.requiredClassRef("scala.volatile") + def VolatileAnnot = VolatileAnnotRef.symbol.asClass + lazy val FieldMetaAnnotRef = ctx.requiredClassRef("scala.annotation.meta.field") + def FieldMetaAnnot = FieldMetaAnnotRef.symbol.asClass + lazy val GetterMetaAnnotRef = ctx.requiredClassRef("scala.annotation.meta.getter") + def GetterMetaAnnot = GetterMetaAnnotRef.symbol.asClass + lazy val SetterMetaAnnotRef = ctx.requiredClassRef("scala.annotation.meta.setter") + def SetterMetaAnnot = SetterMetaAnnotRef.symbol.asClass // convenient one-parameter method types def methOfAny(tp: Type) = MethodType(List(AnyType), tp) @@ -376,23 +475,23 @@ class Definitions { def AnyRefType: Type = AnyRefAlias.typeRef def NothingType: Type = NothingClass.typeRef def NullType: Type = NullClass.typeRef - def SeqType: Type = SeqClass.typeRef - - def UnitType: Type = UnitClass.typeRef - def BooleanType: Type = BooleanClass.typeRef - def ByteType: Type = ByteClass.typeRef - def ShortType: Type = ShortClass.typeRef - def CharType: Type = CharClass.typeRef - def IntType: Type = IntClass.typeRef - def LongType: Type = LongClass.typeRef - def FloatType: Type = FloatClass.typeRef - def DoubleType: Type = DoubleClass.typeRef - def PairType: Type = PairClass.typeRef + def SeqType: Type = SeqTypeRef + + def UnitType: Type = UnitTypeRef + def BooleanType: Type = BooleanTypeRef + def ByteType: Type = ByteTypeRef + def ShortType: Type = ShortTypeRef + def CharType: Type = CharTypeRef + def IntType: Type = IntTypeRef + def LongType: Type = LongTypeRef + def FloatType: Type = FloatTypeRef + def DoubleType: Type = DoubleTypeRef + def PairType: Type = PairTypeRef def StringType: Type = StringClass.typeRef def RepeatedParamType = RepeatedParamClass.typeRef def ThrowableType = ThrowableClass.typeRef - def OptionType = OptionClass.typeRef - def VolatileAnnotType = VolatileAnnot.typeRef + def OptionType = OptionTypeRef + def VolatileAnnotType = VolatileAnnotRef def ClassType(arg: Type)(implicit ctx: Context) = { val ctype = ClassClass.typeRef @@ -409,15 +508,15 @@ class Definitions { object FunctionType { def apply(args: List[Type], resultType: Type)(implicit ctx: Context) = - FunctionClass(args.length).typeRef.appliedTo(args ::: resultType :: Nil) + FunctionTypeRef(args.length).appliedTo(args ::: resultType :: Nil) def unapply(ft: Type)(implicit ctx: Context)/*: Option[(List[Type], Type)]*/ = { // -language:keepUnions difference: unapply needs result type because inferred type // is Some[(List[Type], Type)] | None, which is not a legal unapply type. val tsym = ft.typeSymbol lazy val targs = ft.argInfos - if ((FunctionClasses contains tsym) && - (targs.length - 1 <= MaxFunctionArity) && - (FunctionClass(targs.length - 1) == tsym)) Some(targs.init, targs.last) + val numArgs = targs.length - 1 + if (numArgs >= 0 && numArgs <= MaxFunctionArity && + (FunctionTypeRef(numArgs).symbol == tsym)) Some(targs.init, targs.last) else None } } @@ -425,9 +524,9 @@ class Definitions { object ArrayType { def apply(elem: Type)(implicit ctx: Context) = if (ctx.erasedTypes) JavaArrayType(elem) - else ArrayClass.typeRef.appliedTo(elem :: Nil) + else ArrayTypeRef.appliedTo(elem :: Nil) def unapply(tp: Type)(implicit ctx: Context): Option[Type] = tp.dealias match { - case at: RefinedType if (at isRef ArrayClass) && at.argInfos.length == 1 => Some(at.argInfos.head) + case at: RefinedType if (at isRef ArrayTypeRef.symbol) && at.argInfos.length == 1 => Some(at.argInfos.head) case _ => None } } @@ -448,43 +547,67 @@ class Definitions { // ----- Symbol sets --------------------------------------------------- - lazy val AbstractFunctionClass = mkArityArray("scala.runtime.AbstractFunction", MaxFunctionArity, 0) - lazy val FunctionClass = mkArityArray("scala.Function", MaxFunctionArity, 0) - lazy val Function0_apply = FunctionClass(0).requiredMethod(nme.apply) + lazy val AbstractFunctionTypeRef = mkArityArray("scala.runtime.AbstractFunction", MaxFunctionArity, 0) + def AbstractFunctionClass = AbstractFunctionTypeRef.map(_.symbol.asClass) + lazy val FunctionTypeRef = mkArityArray("scala.Function", MaxFunctionArity, 0) + def FunctionClass = FunctionTypeRef.map(_.symbol.asClass) + lazy val Function0_applyR = FunctionTypeRef(0).symbol.requiredMethodRef(nme.apply) + def Function0_apply = Function0_applyR.symbol - lazy val TupleClass = mkArityArray("scala.Tuple", MaxTupleArity, 2) - lazy val ProductNClass = mkArityArray("scala.Product", MaxTupleArity, 0) + lazy val TupleTypeRef = mkArityArray("scala.Tuple", MaxTupleArity, 2) + lazy val ProductNTypeRef = mkArityArray("scala.Product", MaxTupleArity, 0) - lazy val FunctionClasses: Set[Symbol] = FunctionClass.toSet - lazy val TupleClasses: Set[Symbol] = TupleClass.toSet - lazy val ProductClasses: Set[Symbol] = ProductNClass.toSet + lazy val FunctionTypeRefs: Set[TypeRef] = FunctionTypeRef.toSet + lazy val TupleTypeRefs: Set[TypeRef] = TupleTypeRef.toSet + lazy val ProductTypeRefs: Set[TypeRef] = ProductNTypeRef.toSet - /** `Modules whose members are in the default namespace and their module classes */ - lazy val UnqualifiedOwners = RootImports.toSet ++ RootImports.map(_.moduleClass) + /** If type refers to a class in the scala package, its name, otherwise EmptyTypeName */ + def scalaClassName(ref: Type)(implicit ctx: Context): TypeName = { + val cls = ref.classSymbol + if (cls.isClass && cls.owner == ScalaPackageClass) cls.asClass.name else EmptyTypeName + } - lazy val PhantomClasses = Set[Symbol](AnyClass, AnyValClass, NullClass, NothingClass) + def isVarArityClass(cls: Symbol, prefix: Name) = // ### use scalaClassName + cls.owner == ScalaPackageClass && cls.name.startsWith(prefix) && + cls.name.drop(prefix.length).forall(_.isDigit) + + def isFunctionClass(cls: Symbol) = isVarArityClass(cls, tpnme.Function) + def isAbstractFunctionClass(cls: Symbol) = isVarArityClass(cls, tpnme.AbstractFunction) + def isTupleClass(cls: Symbol) = isVarArityClass(cls, tpnme.Tuple) + def isProductClass(cls: Symbol) = isVarArityClass(cls, tpnme.Product) + + val RootImportFns = List[() => TermRef]( + () => JavaLangPackageVal.termRef, + () => ScalaPackageVal.termRef, + () => ScalaPredefModuleRef, + () => DottyPredefModuleRef) - lazy val isPolymorphicAfterErasure = Set[Symbol](Any_isInstanceOf, Any_asInstanceOf, newRefArrayMethod) + lazy val RootImportTypes = RootImportFns.map(_()) - val RootImportFns = List[() => Symbol](() => JavaLangPackageVal, () => ScalaPackageVal, () => ScalaPredefModule, () => DottyPredefModule) + /** `Modules whose members are in the default namespace and their module classes */ + lazy val UnqualifiedOwnerTypes: Set[NamedType] = + RootImportTypes.toSet[NamedType] ++ RootImportTypes.map(_.symbol.moduleClass.typeRef) + + lazy val PhantomClasses = Set[Symbol](AnyClass, AnyValClass, NullClass, NothingClass) - lazy val RootImports = RootImportFns.map(_()) + lazy val isPolymorphicAfterErasure = // ### Can't be a lazy val, because of newRefArrayMethod! + Set[Symbol](Any_isInstanceOf, Any_asInstanceOf, newRefArrayMethod) def isTupleType(tp: Type)(implicit ctx: Context) = { val arity = tp.dealias.argInfos.length - arity <= MaxTupleArity && (tp isRef TupleClass(arity)) + arity <= MaxTupleArity && TupleTypeRef(arity) != null && (tp isRef TupleTypeRef(arity).symbol) } def tupleType(elems: List[Type]) = { - TupleClass(elems.size).typeRef.appliedTo(elems) + TupleTypeRef(elems.size).appliedTo(elems) } def isProductSubType(tp: Type)(implicit ctx: Context) = - (tp derivesFrom ProductClass) && tp.baseClasses.exists(ProductClasses contains _) + (tp derivesFrom ProductTypeRef.symbol) && tp.baseClasses.exists(isProductClass) def isFunctionType(tp: Type)(implicit ctx: Context) = { val arity = functionArity(tp) - 0 <= arity && arity <= MaxFunctionArity && (tp isRef FunctionClass(arity)) + 0 <= arity && arity <= MaxFunctionArity && (tp isRef FunctionTypeRef(arity).symbol) } def functionArity(tp: Type)(implicit ctx: Context) = tp.dealias.argInfos.length - 1 @@ -556,54 +679,57 @@ class Definitions { // ----- primitive value class machinery ------------------------------------------ - lazy val ScalaNumericValueClassList = List( - ByteClass, - ShortClass, - CharClass, - IntClass, - LongClass, - FloatClass, - DoubleClass) - - lazy val ScalaNumericValueClasses: collection.Set[Symbol] = ScalaNumericValueClassList.toSet - lazy val ScalaValueClasses: collection.Set[Symbol] = ScalaNumericValueClasses + UnitClass + BooleanClass - - lazy val ScalaBoxedClasses = ScalaValueClasses map boxedClass - - private[this] val _boxedClass = mutable.Map[Symbol, Symbol]() - private[this] val _unboxedClass = mutable.Map[Symbol, Symbol]() - - private[this] val _javaTypeToValueClass = mutable.Map[Class[_], Symbol]() - private[this] val _valueClassToJavaType = mutable.Map[Symbol, Class[_]]() - private[this] val _valueClassEnc = mutable.Map[Symbol, Int]() - - val boxedClass: collection.Map[Symbol, Symbol] = _boxedClass - val unboxedClass: collection.Map[Symbol, Symbol] = _boxedClass - val javaTypeToValueClass: collection.Map[Class[_], Symbol] = _javaTypeToValueClass - val valueClassToJavaType: collection.Map[Symbol, Class[_]] = _valueClassToJavaType - val valueClassEnc: collection.Map[Symbol, Int] = _valueClassEnc - - private def valueClassSymbol(name: String, boxed: ClassSymbol, jtype: Class[_], enc: Int): ClassSymbol = { - val vcls = ctx.requiredClass(name) - _unboxedClass(boxed) = vcls - _boxedClass(vcls) = boxed - _javaTypeToValueClass(jtype) = vcls - _valueClassToJavaType(vcls) = jtype - _valueClassEnc(vcls) = enc + lazy val ScalaNumericValueTypeList = List( + ByteTypeRef, + ShortTypeRef, + CharTypeRef, + IntTypeRef, + LongTypeRef, + FloatTypeRef, + DoubleTypeRef) + + lazy val ScalaNumericValueTypes: collection.Set[TypeRef] = ScalaNumericValueTypeList.toSet + def ScalaNumericValueClasses = ScalaNumericValueTypes.map(_.symbol) + lazy val ScalaValueTypes: collection.Set[TypeRef] = ScalaNumericValueTypes + UnitTypeRef + BooleanTypeRef + def ScalaValueClasses = ScalaValueTypes.map(_.symbol) + + lazy val ScalaBoxedTypeRefs = ScalaValueTypes map boxedTypeRef + def ScalaBoxedClasses = ScalaBoxedTypeRefs.map(_.symbol) + + private[this] val _boxedTypeRef = mutable.Map[TypeRef, TypeRef]() // ### Maps over typerefs are not robust! + private[this] val _unboxedTypeRef = mutable.Map[TypeRef, TypeRef]() + + private[this] val _javaTypeToValueTypeRef = mutable.Map[Class[_], TypeRef]() + private[this] val _valueTypeRefToJavaType = mutable.Map[TypeRef, Class[_]]() + private[this] val _valueTypeEnc = mutable.Map[TypeRef, Int]() + + val boxedTypeRef: collection.Map[TypeRef, TypeRef] = _boxedTypeRef + val unboxedTypeRef: collection.Map[TypeRef, TypeRef] = _boxedTypeRef + val javaTypeToValueTypeRef: collection.Map[Class[_], TypeRef] = _javaTypeToValueTypeRef + val valueTypeRefToJavaType: collection.Map[TypeRef, Class[_]] = _valueTypeRefToJavaType + val valueTypeEnc: collection.Map[TypeRef, Int] = _valueTypeEnc + + private def valueTypeRef(name: String, boxed: TypeRef, jtype: Class[_], enc: Int): TypeRef = { + val vcls = ctx.requiredClassRef(name) + _unboxedTypeRef(boxed) = vcls + _boxedTypeRef(vcls) = boxed + _javaTypeToValueTypeRef(jtype) = vcls + _valueTypeRefToJavaType(vcls) = jtype + _valueTypeEnc(vcls) = enc vcls } /** The classes for which a Ref type exists. */ - lazy val refClassKeys: collection.Set[Symbol] = ScalaNumericValueClasses + BooleanClass + ObjectClass + lazy val refTypeKeys: collection.Set[TypeRef] = ScalaNumericValueTypes + BooleanTypeRef + ObjectClass.typeRef - lazy val refClass: Map[Symbol, Symbol] = - refClassKeys.map(rc => rc -> ctx.requiredClass(s"scala.runtime.${rc.name}Ref")).toMap + lazy val refTypeRef: Map[TypeRef, TypeRef] = + refTypeKeys.map(rc => rc -> ctx.requiredClassRef(s"scala.runtime.${rc.name}Ref")).toMap - lazy val volatileRefClass: Map[Symbol, Symbol] = - refClassKeys.map(rc => rc -> ctx.requiredClass(s"scala.runtime.Volatile${rc.name}Ref")).toMap + lazy val volatileRefTypeRef: Map[TypeRef, TypeRef] = + refTypeKeys.map(rc => rc -> ctx.requiredClassRef(s"scala.runtime.Volatile${rc.name}Ref")).toMap - lazy val boxedRefClasses: collection.Set[Symbol] = - refClassKeys.flatMap(k => Set(refClass(k), volatileRefClass(k))) + lazy val boxedRefTypeRefs: collection.Set[TypeRef] = + refTypeKeys.flatMap(k => Set(refTypeRef(k), volatileRefTypeRef(k))) def wrapArrayMethodName(elemtp: Type): TermName = { val cls = elemtp.classSymbol @@ -622,8 +748,10 @@ class Definitions { val BooleanEnc = 17 val UnitEnc = 19 - def isValueSubClass(cls1: Symbol, cls2: Symbol)(implicit ctx: Context) = - valueClassEnc(cls2) % valueClassEnc(cls1) == 0 + def isValueSubType(tref1: TypeRef, tref2: TypeRef)(implicit ctx: Context) = // ### Not stable! + valueTypeEnc(tref2) % valueTypeEnc(tref1) == 0 + def isValueSubClass(sym1: Symbol, sym2: Symbol) = + isValueSubType(sym1.typeRef, sym2.typeRef) // ----- Initialization --------------------------------------------------- diff --git a/src/dotty/tools/dotc/core/Denotations.scala b/src/dotty/tools/dotc/core/Denotations.scala index 65df55a9d..666908fab 100644 --- a/src/dotty/tools/dotc/core/Denotations.scala +++ b/src/dotty/tools/dotc/core/Denotations.scala @@ -207,14 +207,20 @@ object Denotations { def requiredMethod(name: PreName)(implicit ctx: Context): TermSymbol = info.member(name.toTermName).requiredSymbol(_ is Method).asTerm + def requiredMethodRef(name: PreName)(implicit ctx: Context): TermRef = + requiredMethod(name).termRef def requiredMethod(name: PreName, argTypes: List[Type])(implicit ctx: Context): TermSymbol = info.member(name.toTermName).requiredSymbol(x=> (x is Method) && x.info.paramTypess == List(argTypes) ).asTerm + def requiredMethodRef(name: PreName, argTypes: List[Type])(implicit ctx: Context): TermRef = + requiredMethod(name, argTypes).termRef def requiredValue(name: PreName)(implicit ctx: Context): TermSymbol = info.member(name.toTermName).requiredSymbol(_.info.isParameterless).asTerm + def requiredValueRef(name: PreName)(implicit ctx: Context): TermRef = + requiredValue(name).termRef def requiredClass(name: PreName)(implicit ctx: Context): ClassSymbol = info.member(name.toTypeName).requiredSymbol(_.isClass).asClass diff --git a/src/dotty/tools/dotc/core/StdNames.scala b/src/dotty/tools/dotc/core/StdNames.scala index 7c73d95da..e8cddd3d4 100644 --- a/src/dotty/tools/dotc/core/StdNames.scala +++ b/src/dotty/tools/dotc/core/StdNames.scala @@ -176,19 +176,22 @@ object StdNames { final val LAMBDA_ARG_PREFIX: N = "hk$" final val LAMBDA_ARG_PREFIXhead: Char = LAMBDA_ARG_PREFIX.head - final val Any: N = "Any" - final val AnyVal: N = "AnyVal" - final val ExprApi: N = "ExprApi" - final val Mirror: N = "Mirror" - final val Nothing: N = "Nothing" - final val Null: N = "Null" - final val Object: N = "Object" - final val PartialFunction: N = "PartialFunction" - final val PrefixType: N = "PrefixType" - final val Product: N = "Product" - final val Serializable: N = "Serializable" - final val Singleton: N = "Singleton" - final val Throwable: N = "Throwable" + final val AbstractFunction: N = "AbstractFunction" + final val Any: N = "Any" + final val AnyVal: N = "AnyVal" + final val ExprApi: N = "ExprApi" + final val Function: N = "Function" + final val Mirror: N = "Mirror" + final val Nothing: N = "Nothing" + final val Null: N = "Null" + final val Object: N = "Object" + final val PartialFunction: N = "PartialFunction" + final val PrefixType: N = "PrefixType" + final val Product: N = "Product" + final val Serializable: N = "Serializable" + final val Singleton: N = "Singleton" + final val Throwable: N = "Throwable" + final val Tuple: N = "Tuple" final val ClassfileAnnotation: N = "ClassfileAnnotation" final val ClassManifest: N = "ClassManifest" diff --git a/src/dotty/tools/dotc/core/Symbols.scala b/src/dotty/tools/dotc/core/Symbols.scala index 100f87a54..7c9df525c 100644 --- a/src/dotty/tools/dotc/core/Symbols.scala +++ b/src/dotty/tools/dotc/core/Symbols.scala @@ -339,9 +339,13 @@ trait Symbols { this: Context => def requiredPackage(path: PreName): TermSymbol = base.staticRef(path.toTermName).requiredSymbol(_ is Package).asTerm + def requiredPackageRef(path: PreName): TermRef = requiredPackage(path).termRef + def requiredClass(path: PreName): ClassSymbol = base.staticRef(path.toTypeName).requiredSymbol(_.isClass).asClass + def requiredClassRef(path: PreName): TypeRef = requiredClass(path).typeRef + /** Get ClassSymbol if class is either defined in current compilation run * or present on classpath. * Returns NoSymbol otherwise. */ @@ -351,8 +355,15 @@ trait Symbols { this: Context => def requiredModule(path: PreName): TermSymbol = base.staticRef(path.toTermName).requiredSymbol(_ is Module).asTerm - def requiredMethod(cls: ClassSymbol, name: PreName): TermSymbol = - cls.info.member(name.toTermName).requiredSymbol(_ is Method).asTerm + def requiredModuleRef(path: PreName): TermRef = requiredModule(path).termRef + + def requiredMethod(pre: TypeRef, name: PreName): TermSymbol = // ### replace with method in Denotations? + pre.member(name.toTermName).requiredSymbol(_ is Method).asTerm + def requiredMethod(pre: TermRef, name: PreName): TermSymbol = + requiredMethod(pre.symbol.moduleClass.typeRef, name) + + def requiredMethodRef(pre: TypeRef, name: PreName): TermRef = requiredMethod(pre, name).termRef + def requiredMethodRef(pre: TermRef, name: PreName): TermRef = requiredMethod(pre, name).termRef } object Symbols { diff --git a/src/dotty/tools/dotc/printing/PlainPrinter.scala b/src/dotty/tools/dotc/printing/PlainPrinter.scala index 5daef9fb8..8b2d68570 100644 --- a/src/dotty/tools/dotc/printing/PlainPrinter.scala +++ b/src/dotty/tools/dotc/printing/PlainPrinter.scala @@ -245,10 +245,10 @@ class PlainPrinter(_ctx: Context) extends Printer { } } - protected def isOmittablePrefix(sym: Symbol) = - (defn.UnqualifiedOwners contains sym) || isEmptyPrefix(sym) + protected def isOmittablePrefix(sym: Symbol): Boolean = + defn.UnqualifiedOwnerTypes.exists(_.symbol == sym) || isEmptyPrefix(sym) - protected def isEmptyPrefix(sym: Symbol) = + protected def isEmptyPrefix(sym: Symbol): Boolean = sym.isEffectiveRoot || sym.isAnonymousClass || sym.name.isReplWrapperName /** String representation of a definition's type following its name, diff --git a/src/dotty/tools/dotc/printing/RefinedPrinter.scala b/src/dotty/tools/dotc/printing/RefinedPrinter.scala index d50b551fa..7065976dc 100644 --- a/src/dotty/tools/dotc/printing/RefinedPrinter.scala +++ b/src/dotty/tools/dotc/printing/RefinedPrinter.scala @@ -115,8 +115,8 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) { val cls = tycon.typeSymbol if (cls.typeParams.length == args.length) { if (tycon.isRepeatedParam) return toTextLocal(args.head) ~ "*" - if (defn.FunctionClasses contains cls) return toTextFunction(args) - if (defn.TupleClasses contains cls) return toTextTuple(args) + if (defn.isFunctionClass(cls)) return toTextFunction(args) + if (defn.isTupleClass(cls)) return toTextTuple(args) } return (toTextLocal(tycon) ~ "[" ~ Text(args map argText, ", ") ~ "]").close } diff --git a/src/dotty/tools/dotc/transform/CapturedVars.scala b/src/dotty/tools/dotc/transform/CapturedVars.scala index 0f1a60282..bd0c7f203 100644 --- a/src/dotty/tools/dotc/transform/CapturedVars.scala +++ b/src/dotty/tools/dotc/transform/CapturedVars.scala @@ -54,16 +54,19 @@ class CapturedVars extends MiniPhase with IdentityDenotTransformer { thisTransfo /** The {Volatile|}{Int|Double|...|Object}Ref class corresponding to the class `cls`, * depending on whether the reference should be @volatile */ - def refCls(cls: Symbol, isVolatile: Boolean)(implicit ctx: Context): Symbol = { - val refMap = if (isVolatile) defn.volatileRefClass else defn.refClass - refMap.getOrElse(cls, refMap(defn.ObjectClass)) + def refTypeRef(cls: Symbol, isVolatile: Boolean)(implicit ctx: Context): TypeRef = { + val refMap = if (isVolatile) defn.volatileRefTypeRef else defn.refTypeRef + if (cls.isClass) { + refMap.getOrElse(cls.typeRef, refMap(defn.ObjectClass.typeRef)) + } + else refMap(defn.ObjectClass.typeRef) } override def prepareForValDef(vdef: ValDef)(implicit ctx: Context) = { val sym = vdef.symbol if (captured contains sym) { val newd = sym.denot(ctx.withPhase(thisTransform)).copySymDenotation( - info = refCls(sym.info.classSymbol, sym.hasAnnotation(defn.VolatileAnnot)).typeRef, + info = refTypeRef(sym.info.classSymbol, sym.hasAnnotation(defn.VolatileAnnot)), initFlags = sym.flags &~ Mutable) newd.removeAnnotation(defn.VolatileAnnot) newd.installAfter(thisTransform) @@ -109,11 +112,13 @@ class CapturedVars extends MiniPhase with IdentityDenotTransformer { thisTransfo * drop the cast. */ override def transformAssign(tree: Assign)(implicit ctx: Context, info: TransformerInfo): Tree = { + def isBoxedRefType(sym: Symbol) = + sym.isClass && defn.boxedRefTypeRefs.exists(_.symbol == sym) def recur(lhs: Tree): Tree = lhs match { case TypeApply(Select(qual, nme.asInstanceOf_), _) => val Select(_, nme.elem) = qual recur(qual) - case Select(_, nme.elem) if defn.boxedRefClasses.contains(lhs.symbol.maybeOwner) => + case Select(_, nme.elem) if isBoxedRefType(lhs.symbol.maybeOwner) => val tempDef = transformFollowing(SyntheticValDef(ctx.freshName("ev$").toTermName, tree.rhs)) transformFollowing(Block(tempDef :: Nil, cpy.Assign(tree)(lhs, ref(tempDef.symbol)))) case _ => diff --git a/src/dotty/tools/dotc/transform/ClassOf.scala b/src/dotty/tools/dotc/transform/ClassOf.scala index 4d6bf2dc9..cc7f8bad3 100644 --- a/src/dotty/tools/dotc/transform/ClassOf.scala +++ b/src/dotty/tools/dotc/transform/ClassOf.scala @@ -24,30 +24,15 @@ class ClassOf extends MiniPhaseTransform { private var classOfMethod: TermSymbol = _ override def prepareForUnit(tree: tpd.Tree)(implicit ctx: Context): TreeTransform = { - val predefModule = ctx.definitions.ScalaPredefModule - classOfMethod = ctx.requiredMethod(predefModule.moduleClass.asClass, nme.classOf) + val predefModule = ctx.definitions.ScalaPredefModuleRef + classOfMethod = ctx.requiredMethod(predefModule, nme.classOf) this } - override def transformTypeApply(tree: TypeApply)(implicit ctx: Context, info: TransformerInfo): Tree = { + override def transformTypeApply(tree: TypeApply)(implicit ctx: Context, info: TransformerInfo): Tree = if (tree.symbol eq classOfMethod) { - val tp = tree.args.head.tpe - val defn = ctx.definitions - val claz = tp.classSymbol - - def TYPE(module: TermSymbol) = ref(module).select(nme.TYPE_).ensureConforms(tree.tpe) - claz match { - case defn.BooleanClass => TYPE(defn.BoxedBooleanModule) - case defn.ByteClass => TYPE(defn.BoxedByteModule) - case defn.ShortClass => TYPE(defn.BoxedShortModule) - case defn.CharClass => TYPE(defn.BoxedCharModule) - case defn.IntClass => TYPE(defn.BoxedIntModule) - case defn.LongClass => TYPE(defn.BoxedLongModule) - case defn.FloatClass => TYPE(defn.BoxedFloatModule) - case defn.DoubleClass => TYPE(defn.BoxedDoubleModule) - case defn.UnitClass => TYPE(defn.BoxedVoidModule) - case _ => Literal(Constant(TypeErasure.erasure(tp))) - } - } else tree - } + val targ = tree.args.head.tpe + tree.clsOf(targ, Literal(Constant(TypeErasure.erasure(targ)))) + } + else tree } diff --git a/src/dotty/tools/dotc/transform/ClassTags.scala b/src/dotty/tools/dotc/transform/ClassTags.scala index 9d8abae93..203898ef0 100644 --- a/src/dotty/tools/dotc/transform/ClassTags.scala +++ b/src/dotty/tools/dotc/transform/ClassTags.scala @@ -31,9 +31,9 @@ class ClassTags extends MiniPhaseTransform with IdentityDenotTransformer { thisT override def prepareForUnit(tree: tpd.Tree)(implicit ctx: Context): TreeTransform = { - val predefClass = defn.DottyPredefModule.moduleClass.asClass - classTagCache = ctx.requiredMethod(predefClass, nme.classTag) - typeTagCache = ctx.requiredMethod(predefClass, nme.typeTag) + val dottyPredef = defn.DottyPredefModuleRef + classTagCache = ctx.requiredMethod(dottyPredef, nme.classTag) + typeTagCache = ctx.requiredMethod(dottyPredef, nme.typeTag) scala2ClassTagModule = ctx.requiredModule("scala.reflect.ClassTag") this } diff --git a/src/dotty/tools/dotc/transform/Erasure.scala b/src/dotty/tools/dotc/transform/Erasure.scala index a414c6399..a540dafb0 100644 --- a/src/dotty/tools/dotc/transform/Erasure.scala +++ b/src/dotty/tools/dotc/transform/Erasure.scala @@ -218,7 +218,7 @@ object Erasure extends TypeTestsCasts{ case (JavaArrayType(treeElem), JavaArrayType(ptElem)) if treeElem.widen.isPrimitiveValueType && !ptElem.isPrimitiveValueType => // See SI-2386 for one example of when this might be necessary. - cast(ref(defn.runtimeMethod(nme.toObjectArray)).appliedTo(tree), pt) + cast(ref(defn.runtimeMethodRef(nme.toObjectArray)).appliedTo(tree), pt) case (_, ErasedValueType(cls, _)) => ref(u2evt(cls)).appliedTo(tree) case _ => @@ -388,10 +388,10 @@ object Erasure extends TypeTestsCasts{ } private def runtimeCallWithProtoArgs(name: Name, pt: Type, args: Tree*)(implicit ctx: Context): Tree = { - val meth = defn.runtimeMethod(name) - val followingParams = meth.info.firstParamTypes.drop(args.length) + val meth = defn.runtimeMethodRef(name) + val followingParams = meth.symbol.info.firstParamTypes.drop(args.length) val followingArgs = protoArgs(pt).zipWithConserve(followingParams)(typedExpr).asInstanceOf[List[tpd.Tree]] - ref(defn.runtimeMethod(name)).appliedToArgs(args.toList ++ followingArgs) + ref(meth).appliedToArgs(args.toList ++ followingArgs) } private def protoArgs(pt: Type): List[untpd.Tree] = pt match { diff --git a/src/dotty/tools/dotc/transform/FirstTransform.scala b/src/dotty/tools/dotc/transform/FirstTransform.scala index aecc1b86f..4b27c9efe 100644 --- a/src/dotty/tools/dotc/transform/FirstTransform.scala +++ b/src/dotty/tools/dotc/transform/FirstTransform.scala @@ -100,7 +100,7 @@ class FirstTransform extends MiniPhaseTransform with IdentityDenotTransformer wi if (ddef.symbol.hasAnnotation(defn.NativeAnnot)) { ddef.symbol.resetFlag(Deferred) DefDef(ddef.symbol.asTerm, - _ => ref(defn.Sys_error).withPos(ddef.pos) + _ => ref(defn.Sys_errorR).withPos(ddef.pos) .appliedTo(Literal(Constant("native method stub")))) } else ddef } diff --git a/src/dotty/tools/dotc/transform/GetClass.scala b/src/dotty/tools/dotc/transform/GetClass.scala index 4d8c8ae40..9d182382d 100644 --- a/src/dotty/tools/dotc/transform/GetClass.scala +++ b/src/dotty/tools/dotc/transform/GetClass.scala @@ -4,7 +4,6 @@ package transform import ast.tpd import core.Contexts.Context import core.StdNames.nme -import core.Symbols.TermSymbol import core.Phases.Phase import TreeTransforms.{MiniPhaseTransform, TransformerInfo} @@ -24,25 +23,8 @@ class GetClass extends MiniPhaseTransform { override def transformApply(tree: Apply)(implicit ctx: Context, info: TransformerInfo): Tree = { import ast.Trees._ - tree match { - case Apply(Select(qual, nme.getClass_), Nil) => - val defn = ctx.definitions - val claz = qual.tpe.widen.classSymbol - - def TYPE(module: TermSymbol) = ref(module).select(nme.TYPE_).ensureConforms(tree.tpe) - claz match { - case defn.BooleanClass => TYPE(defn.BoxedBooleanModule) - case defn.ByteClass => TYPE(defn.BoxedByteModule) - case defn.ShortClass => TYPE(defn.BoxedShortModule) - case defn.CharClass => TYPE(defn.BoxedCharModule) - case defn.IntClass => TYPE(defn.BoxedIntModule) - case defn.LongClass => TYPE(defn.BoxedLongModule) - case defn.FloatClass => TYPE(defn.BoxedFloatModule) - case defn.DoubleClass => TYPE(defn.BoxedDoubleModule) - case defn.UnitClass => TYPE(defn.BoxedVoidModule) - case _ => tree - } + case Apply(Select(qual, nme.getClass_), Nil) => tree.clsOf(qual.tpe.widen, tree) case _ => tree } } diff --git a/src/dotty/tools/dotc/transform/NonLocalReturns.scala b/src/dotty/tools/dotc/transform/NonLocalReturns.scala index 1f18a7318..a58a0fbda 100644 --- a/src/dotty/tools/dotc/transform/NonLocalReturns.scala +++ b/src/dotty/tools/dotc/transform/NonLocalReturns.scala @@ -29,7 +29,7 @@ class NonLocalReturns extends MiniPhaseTransform { thisTransformer => /** The type of a non-local return expression with given argument type */ private def nonLocalReturnExceptionType(argtype: Type)(implicit ctx: Context) = - defn.NonLocalReturnControlClass.typeRef.appliedTo(argtype) + defn.NonLocalReturnControlTypeRef.appliedTo(argtype) /** A hashmap from method symbols to non-local return keys */ private val nonLocalReturnKeys = mutable.Map[Symbol, TermSymbol]() @@ -50,7 +50,7 @@ class NonLocalReturns extends MiniPhaseTransform { thisTransformer => private def nonLocalReturnThrow(expr: Tree, meth: Symbol)(implicit ctx: Context) = Throw( New( - defn.NonLocalReturnControlClass.typeRef, + defn.NonLocalReturnControlTypeRef, ref(nonLocalReturnKey(meth)) :: expr.ensureConforms(defn.ObjectType) :: Nil)) /** Transform (body, key) to: @@ -68,7 +68,7 @@ class NonLocalReturns extends MiniPhaseTransform { thisTransformer => */ private def nonLocalReturnTry(body: Tree, key: TermSymbol, meth: Symbol)(implicit ctx: Context) = { val keyDef = ValDef(key, New(defn.ObjectType, Nil)) - val nonLocalReturnControl = defn.NonLocalReturnControlClass.typeRef + val nonLocalReturnControl = defn.NonLocalReturnControlTypeRef val ex = ctx.newSymbol(meth, nme.ex, EmptyFlags, nonLocalReturnControl, coord = body.pos) val pat = BindTyped(ex, nonLocalReturnControl) val rhs = If( diff --git a/src/dotty/tools/dotc/transform/PatternMatcher.scala b/src/dotty/tools/dotc/transform/PatternMatcher.scala index 2df7a9825..a47762ebe 100644 --- a/src/dotty/tools/dotc/transform/PatternMatcher.scala +++ b/src/dotty/tools/dotc/transform/PatternMatcher.scala @@ -134,7 +134,7 @@ class PatternMatcher extends MiniPhaseTransform with DenotTransformer {thisTrans // for name-based matching, but this was an expedient route for the basics. def drop(tgt: Tree)(n: Int): Tree = { def callDirect = tgt.select(nme.drop).appliedTo(Literal(Constant(n))) - def callRuntime = ref(defn.traversableDropMethod).appliedTo(tgt, Literal(Constant(n))) + def callRuntime = ref(defn.ScalaRuntime_drop).appliedTo(tgt, Literal(Constant(n))) def needsRuntime = !(tgt.tpe derivesFrom defn.SeqClass) /*typeOfMemberNamedDrop(tgt.tpe) == NoType*/ @@ -201,7 +201,7 @@ class PatternMatcher extends MiniPhaseTransform with DenotTransformer {thisTrans // catchAll.isEmpty iff no synthetic default case needed (the (last) user-defined case is a default) // if the last user-defined case is a default, it will never jump to the next case; it will go immediately to matchEnd val catchAllDef = matchFailGen.map { _(scrutSym)} - .getOrElse(Throw(New(defn.MatchErrorType, List(ref(scrutSym))))) + .getOrElse(Throw(New(defn.MatchErrorTypeRef, List(ref(scrutSym))))) val matchFail = newSynthCaseLabel(ctx.freshName("matchFail"), MethodType(Nil, restpe)) val catchAllDefBody = DefDef(matchFail, catchAllDef) @@ -878,7 +878,7 @@ class PatternMatcher extends MiniPhaseTransform with DenotTransformer {thisTrans // unlike in scalac SubstOnlyTreeMakers are maintained. val casesRebindingPropagated = casesRaw map (propagateRebindings(_, NoRebindings)) - def matchFailGen = matchFailGenOverride orElse Some((arg: Symbol) => Throw(New(defn.MatchErrorType, List(ref(arg))))) + def matchFailGen = matchFailGenOverride orElse Some((arg: Symbol) => Throw(New(defn.MatchErrorTypeRef, List(ref(arg))))) ctx.debuglog("combining cases: " + (casesRebindingPropagated.map(_.mkString(" >> ")).mkString("{", "\n", "}"))) diff --git a/src/dotty/tools/dotc/transform/SyntheticMethods.scala b/src/dotty/tools/dotc/transform/SyntheticMethods.scala index fa931a379..a496f80ce 100644 --- a/src/dotty/tools/dotc/transform/SyntheticMethods.scala +++ b/src/dotty/tools/dotc/transform/SyntheticMethods.scala @@ -77,7 +77,7 @@ class SyntheticMethods(thisTransformer: DenotTransformer) { coord = clazz.coord).enteredAfter(thisTransformer).asTerm def forwardToRuntime(vrefss: List[List[Tree]]): Tree = - ref(defn.runtimeMethod("_" + sym.name.toString)).appliedToArgs(This(clazz) :: vrefss.head) + ref(defn.runtimeMethodRef("_" + sym.name.toString)).appliedToArgs(This(clazz) :: vrefss.head) def syntheticRHS(implicit ctx: Context): List[List[Tree]] => Tree = synthetic.name match { case nme.hashCode_ if isDerivedValueClass(clazz) => vrefss => valueHashCodeBody @@ -161,20 +161,17 @@ class SyntheticMethods(thisTransformer: DenotTransformer) { } /** The hashCode implementation for given symbol `sym`. */ - def hashImpl(sym: Symbol)(implicit ctx: Context): Tree = { - val d = defn - import d._ - sym.info.finalResultType.typeSymbol match { - case UnitClass | NullClass => Literal(Constant(0)) - case BooleanClass => If(ref(sym), Literal(Constant(1231)), Literal(Constant(1237))) - case IntClass => ref(sym) - case ShortClass | ByteClass | CharClass => ref(sym).select(nme.toInt) - case LongClass => ref(staticsMethod("longHash")).appliedTo(ref(sym)) - case DoubleClass => ref(staticsMethod("doubleHash")).appliedTo(ref(sym)) - case FloatClass => ref(staticsMethod("floatHash")).appliedTo(ref(sym)) - case _ => ref(staticsMethod("anyHash")).appliedTo(ref(sym)) + def hashImpl(sym: Symbol)(implicit ctx: Context): Tree = + defn.scalaClassName(sym.info.finalResultType) match { + case tpnme.Unit | tpnme.Null => Literal(Constant(0)) + case tpnme.Boolean => If(ref(sym), Literal(Constant(1231)), Literal(Constant(1237))) + case tpnme.Int => ref(sym) + case tpnme.Short | tpnme.Byte | tpnme.Char => ref(sym).select(nme.toInt) + case tpnme.Long => ref(defn.staticsMethod("longHash")).appliedTo(ref(sym)) + case tpnme.Double => ref(defn.staticsMethod("doubleHash")).appliedTo(ref(sym)) + case tpnme.Float => ref(defn.staticsMethod("floatHash")).appliedTo(ref(sym)) + case _ => ref(defn.staticsMethod("anyHash")).appliedTo(ref(sym)) } - } /** The class * diff --git a/src/dotty/tools/dotc/transform/TypeTestsCasts.scala b/src/dotty/tools/dotc/transform/TypeTestsCasts.scala index b2d45b661..80c3b654e 100644 --- a/src/dotty/tools/dotc/transform/TypeTestsCasts.scala +++ b/src/dotty/tools/dotc/transform/TypeTestsCasts.scala @@ -50,7 +50,7 @@ trait TypeTestsCasts { Literal(Constant(true)) withPos tree.pos else if (argCls.isPrimitiveValueClass) if (qualCls.isPrimitiveValueClass) Literal(Constant(qualCls == argCls)) withPos tree.pos - else transformIsInstanceOf(expr, defn.boxedClass(argCls).typeRef) + else transformIsInstanceOf(expr, defn.boxedTypeRef(argCls.typeRef)) // ### unstable else argType.dealias match { case _: SingletonType => val cmpOp = if (argType derivesFrom defn.AnyValClass) defn.Any_equals else defn.Object_eq @@ -70,7 +70,7 @@ trait TypeTestsCasts { } case defn.MultiArrayType(elem, ndims) if isUnboundedGeneric(elem) => def isArrayTest(arg: Tree) = - ref(defn.runtimeMethod(nme.isArray)).appliedTo(arg, Literal(Constant(ndims))) + ref(defn.runtimeMethodRef(nme.isArray)).appliedTo(arg, Literal(Constant(ndims))) if (ndims == 1) isArrayTest(qual) else evalOnce(qual) { qual1 => derivedTree(qual1, defn.Any_isInstanceOf, qual1.tpe) and isArrayTest(qual1) diff --git a/src/dotty/tools/dotc/typer/Applications.scala b/src/dotty/tools/dotc/typer/Applications.scala index 87bed8895..2e945683b 100644 --- a/src/dotty/tools/dotc/typer/Applications.scala +++ b/src/dotty/tools/dotc/typer/Applications.scala @@ -1102,8 +1102,8 @@ trait Applications extends Compatibility { self: Typer => } val clss = numericClasses(ts, Set()) if (clss.size > 1) { - val lub = defn.ScalaNumericValueClassList.find(lubCls => - clss.forall(defn.isValueSubClass(_, lubCls))).get.typeRef + val lub = defn.ScalaNumericValueTypeList.find(lubTpe => + clss.forall(cls => defn.isValueSubType(cls.typeRef, lubTpe))).get ts.mapConserve(adapt(_, lub)) } else ts diff --git a/src/dotty/tools/dotc/typer/ImportInfo.scala b/src/dotty/tools/dotc/typer/ImportInfo.scala index fe999b561..2ca90311f 100644 --- a/src/dotty/tools/dotc/typer/ImportInfo.scala +++ b/src/dotty/tools/dotc/typer/ImportInfo.scala @@ -11,9 +11,9 @@ import Decorators.StringInterpolators object ImportInfo { /** The import info for a root import from given symbol `sym` */ - def rootImport(sym: () => Symbol)(implicit ctx: Context) = { + def rootImport(refFn: () => TermRef)(implicit ctx: Context) = { val selectors = untpd.Ident(nme.WILDCARD) :: Nil - def expr = tpd.Ident(sym().valRef) + def expr = tpd.Ident(refFn()) def imp = tpd.Import(expr, selectors) new ImportInfo(imp.symbol, selectors, isRootImport = true) } @@ -101,7 +101,7 @@ class ImportInfo(symf: => Symbol, val selectors: List[untpd.Tree], val isRootImp case Pair(_, Ident(nme.WILDCARD)) => true case _ => false } - if ((defn.RootImports contains sym) && hasMaskingSelector) sym else NoSymbol + if ((defn.RootImportTypes exists (_.symbol == sym)) && hasMaskingSelector) sym else NoSymbol } override def toString = { |