From d78c9d360182d87ba78d55fa255859cc89e2d95d Mon Sep 17 00:00:00 2001 From: Dmitry Petrashko Date: Fri, 5 Sep 2014 12:51:36 +0200 Subject: Definitions used by pattern matcher --- src/dotty/tools/dotc/core/Definitions.scala | 32 ++++++++++++++++++++++++----- 1 file changed, 27 insertions(+), 5 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 72c42e719..a47cae560 100644 --- a/src/dotty/tools/dotc/core/Definitions.scala +++ b/src/dotty/tools/dotc/core/Definitions.scala @@ -4,6 +4,7 @@ package core import Types._, Contexts._, Symbols._, Denotations._, SymDenotations._, StdNames._, Names._ import Flags._, Scopes._, Decorators._, NameOps._, util.Positions._ +import TypeApplications._ import pickling.UnPickler.ensureConstructor import scala.annotation.{ switch, meta } import scala.collection.{ mutable, immutable } @@ -103,10 +104,10 @@ class Definitions { lazy val EmptyPackageVal = EmptyPackageClass.sourceModule.entered lazy val ScalaPackageVal = ctx.requiredPackage("scala") + lazy val ScalaMathPackageVal = ctx.requiredPackage("scala.math") lazy val ScalaPackageClass = ScalaPackageVal.moduleClass.asClass lazy val JavaPackageVal = ctx.requiredPackage("java") 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) @@ -191,7 +192,6 @@ class Definitions { lazy val ScalaStaticsClass = ScalaStaticsModule.moduleClass.asClass def staticsMethod(name: PreName) = ctx.requiredMethod(ScalaStaticsClass, name) - lazy val DottyPredefModule = ctx.requiredModule("dotty.DottyPredef") lazy val NilModule = ctx.requiredModule("scala.collection.immutable.Nil") lazy val PredefConformsClass = ctx.requiredClass("scala.Predef." + tpnme.Conforms) @@ -204,11 +204,15 @@ class Definitions { ScalaPackageClass, tpnme.Singleton, Trait | Interface | 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 traversableDropMethod = ctx.requiredMethod(ScalaRuntimeModuleClass, 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) @@ -220,6 +224,13 @@ class Definitions { 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( x => (x is Method) && (x.info.firstParamTypes.head isRef defn.LongClass) @@ -264,6 +275,8 @@ class Definitions { 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") @@ -282,9 +295,7 @@ class Definitions { 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 LanguageModuleClass = ctx.requiredModule("dotty.language").moduleClass.asClass // Annotation base classes @@ -330,6 +341,7 @@ class Definitions { def NothingType: Type = NothingClass.typeRef def NullType: Type = NullClass.typeRef def SeqType: Type = SeqClass.typeRef + def ObjectArrayType = ArrayType(ObjectType) def UnitType: Type = UnitClass.typeRef def BooleanType: Type = BooleanClass.typeRef @@ -411,20 +423,29 @@ class Definitions { lazy val TupleClasses: Set[Symbol] = TupleClass.toSet lazy val ProductClasses: Set[Symbol] = ProductNClass.toSet + lazy val RepeatedParamClasses: Set[Symbol] = Set(RepeatedParamClass, JavaRepeatedParamClass) + /** `Modules whose members are in the default namespace and their module classes */ lazy val UnqualifiedOwners = RootImports.toSet ++ RootImports.map(_.moduleClass) lazy val PhantomClasses = Set[Symbol](AnyClass, AnyValClass, NullClass, NothingClass) + lazy val asInstanceOfMethods = Set[Symbol](Any_asInstanceOf) + lazy val isInstanceOfMethods = Set[Symbol](Any_isInstanceOf) + lazy val typeTestsOrCasts = asInstanceOfMethods ++ isInstanceOfMethods + lazy val RootImports = List[Symbol](JavaLangPackageVal, ScalaPackageVal, ScalaPredefModule, DottyPredefModule) lazy val overriddenBySynthetic = Set[Symbol](Any_equals, Any_hashCode, Any_toString, Product_canEqual) - def isTupleType(tp: Type)(implicit ctx: Context) = { val arity = tp.dealias.argInfos.length arity <= MaxTupleArity && (tp isRef TupleClass(arity)) } + def tupleType(elems: List[Type]) = { + TupleClass(elems.size).typeRef.appliedTo(elems) + } + def isProductSubType(tp: Type)(implicit ctx: Context) = (tp derivesFrom ProductClass) && tp.baseClasses.exists(ProductClasses contains _) @@ -574,6 +595,7 @@ class Definitions { AnyClass, AnyRefAlias, RepeatedParamClass, + JavaRepeatedParamClass, ByNameParamClass2x, AnyValClass, NullClass, -- cgit v1.2.3