summaryrefslogtreecommitdiff
path: root/examples/scala-js/compiler/src/main/scala/scala/scalajs/compiler/TypeKinds.scala
diff options
context:
space:
mode:
Diffstat (limited to 'examples/scala-js/compiler/src/main/scala/scala/scalajs/compiler/TypeKinds.scala')
-rw-r--r--examples/scala-js/compiler/src/main/scala/scala/scalajs/compiler/TypeKinds.scala252
1 files changed, 0 insertions, 252 deletions
diff --git a/examples/scala-js/compiler/src/main/scala/scala/scalajs/compiler/TypeKinds.scala b/examples/scala-js/compiler/src/main/scala/scala/scalajs/compiler/TypeKinds.scala
deleted file mode 100644
index 774be68..0000000
--- a/examples/scala-js/compiler/src/main/scala/scala/scalajs/compiler/TypeKinds.scala
+++ /dev/null
@@ -1,252 +0,0 @@
-/* Scala.js compiler
- * Copyright 2013 LAMP/EPFL
- * @author Sébastien Doeraene
- */
-
-package scala.scalajs.compiler
-
-import scala.tools.nsc._
-
-import scala.scalajs.ir
-import ir.{Definitions, Types}
-
-/** Glue representation of types as seen from the IR but still with a
- * reference to the Symbols.
- *
- * @author Sébastien Doeraene
- */
-trait TypeKinds extends SubComponent { this: GenJSCode =>
- import global._
- import jsAddons._
- import definitions._
-
- lazy val ObjectReference = REFERENCE(definitions.ObjectClass)
-
- lazy val VoidKind = VOID
- lazy val BooleanKind = BOOL
- lazy val CharKind = INT(CharClass)
- lazy val ByteKind = INT(ByteClass)
- lazy val ShortKind = INT(ShortClass)
- lazy val IntKind = INT(IntClass)
- lazy val LongKind = LONG
- lazy val FloatKind = FLOAT(FloatClass)
- lazy val DoubleKind = FLOAT(DoubleClass)
-
- /** TypeKinds for Scala primitive types. */
- lazy val primitiveTypeMap: Map[Symbol, TypeKind] = {
- import definitions._
- Map(
- UnitClass -> VoidKind,
- BooleanClass -> BooleanKind,
- CharClass -> CharKind,
- ByteClass -> ByteKind,
- ShortClass -> ShortKind,
- IntClass -> IntKind,
- LongClass -> LongKind,
- FloatClass -> FloatKind,
- DoubleClass -> DoubleKind
- )
- }
-
- /** Glue representation of types as seen from the IR but still with a
- * reference to the Symbols.
- */
- sealed abstract class TypeKind {
- def isReferenceType = false
- def isArrayType = false
- def isValueType = false
-
- def toIRType: Types.Type
- def toReferenceType: Types.ReferenceType
- }
-
- sealed abstract class TypeKindButArray extends TypeKind {
- protected def typeSymbol: Symbol
-
- override def toReferenceType: Types.ClassType =
- Types.ClassType(encodeClassFullName(typeSymbol))
- }
-
- /** The void, for trees that can only appear in statement position. */
- case object VOID extends TypeKindButArray {
- protected def typeSymbol = UnitClass
- def toIRType: Types.NoType.type = Types.NoType
- }
-
- sealed abstract class ValueTypeKind extends TypeKindButArray {
- override def isValueType = true
-
- val primitiveCharCode: Char = typeSymbol match {
- case BooleanClass => 'Z'
- case CharClass => 'C'
- case ByteClass => 'B'
- case ShortClass => 'S'
- case IntClass => 'I'
- case LongClass => 'J'
- case FloatClass => 'F'
- case DoubleClass => 'D'
- case x => abort("Unknown primitive type: " + x.fullName)
- }
- }
-
- /** Integer number (Byte, Short, Char or Int). */
- case class INT private[TypeKinds] (typeSymbol: Symbol) extends ValueTypeKind {
- def toIRType: Types.IntType.type = Types.IntType
- }
-
- /** Long */
- case object LONG extends ValueTypeKind {
- protected def typeSymbol = definitions.LongClass
- def toIRType: Types.LongType.type = Types.LongType
- }
-
- /** Floating-point number (Float or Double). */
- case class FLOAT private[TypeKinds] (typeSymbol: Symbol) extends ValueTypeKind {
- def toIRType: Types.Type =
- if (typeSymbol == FloatClass) Types.FloatType
- else Types.DoubleType
- }
-
- /** Boolean */
- case object BOOL extends ValueTypeKind {
- protected def typeSymbol = definitions.BooleanClass
- def toIRType: Types.BooleanType.type = Types.BooleanType
- }
-
- /** Nothing */
- case object NOTHING extends TypeKindButArray {
- protected def typeSymbol = definitions.NothingClass
- def toIRType: Types.NothingType.type = Types.NothingType
- override def toReferenceType: Types.ClassType =
- Types.ClassType(Definitions.RuntimeNothingClass)
- }
-
- /** Null */
- case object NULL extends TypeKindButArray {
- protected def typeSymbol = definitions.NullClass
- def toIRType: Types.NullType.type = Types.NullType
- override def toReferenceType: Types.ClassType =
- Types.ClassType(Definitions.RuntimeNullClass)
- }
-
- /** An object */
- case class REFERENCE private[TypeKinds] (typeSymbol: Symbol) extends TypeKindButArray {
- override def toString(): String = "REFERENCE(" + typeSymbol.fullName + ")"
- override def isReferenceType = true
-
- def toIRType: Types.Type = encodeClassType(typeSymbol)
- }
-
- /** An array */
- case class ARRAY private[TypeKinds] (elem: TypeKind) extends TypeKind {
- override def toString = "ARRAY[" + elem + "]"
- override def isArrayType = true
-
- def dimensions: Int = elem match {
- case a: ARRAY => a.dimensions + 1
- case _ => 1
- }
-
- override def toIRType: Types.ArrayType = toReferenceType
-
- override def toReferenceType: Types.ArrayType = {
- Types.ArrayType(
- elementKind.toReferenceType.className,
- dimensions)
- }
-
- /** The ultimate element type of this array. */
- def elementKind: TypeKindButArray = elem match {
- case a: ARRAY => a.elementKind
- case k: TypeKindButArray => k
- }
- }
-
- ////////////////// Conversions //////////////////////////////
-
- def toIRType(t: Type): Types.Type =
- toTypeKind(t).toIRType
-
- def toReferenceType(t: Type): Types.ReferenceType =
- toTypeKind(t).toReferenceType
-
- // The following code is a hard copy-and-paste from backend.icode.TypeKinds
-
- /** Return the TypeKind of the given type
- *
- * Call to .normalize fixes #3003 (follow type aliases). Otherwise,
- * arrayOrClassType below would return ObjectReference.
- */
- def toTypeKind(t: Type): TypeKind = t.normalize match {
- case ThisType(ArrayClass) => ObjectReference
- case ThisType(sym) => newReference(sym)
- case SingleType(_, sym) => primitiveOrRefType(sym)
- case ConstantType(_) => toTypeKind(t.underlying)
- case TypeRef(_, sym, args) => primitiveOrClassType(sym, args)
- case ClassInfoType(_, _, ArrayClass) => abort("ClassInfoType to ArrayClass!")
- case ClassInfoType(_, _, sym) => primitiveOrRefType(sym)
-
- // !!! Iulian says types which make no sense after erasure should not reach here,
- // which includes the ExistentialType, AnnotatedType, RefinedType. I don't know
- // if the first two cases exist because they do or as a defensive measure, but
- // at the time I added it, RefinedTypes were indeed reaching here.
- // !!! Removed in JavaScript backend because I do not know what to do with lub
- //case ExistentialType(_, t) => toTypeKind(t)
- // Apparently, this case does occur (see pos/CustomGlobal.scala)
- case t: AnnotatedType => toTypeKind(t.underlying)
- //case RefinedType(parents, _) => parents map toTypeKind reduceLeft lub
-
- /* This case is not in scalac. We need it for the test
- * run/valueclasses-classtag-existential. I have no idea how icode does
- * not fail this test: we do everything the same as icode up to here.
- */
- case tpe: ErasedValueType => newReference(tpe.valueClazz)
-
- // For sure WildcardTypes shouldn't reach here either, but when
- // debugging such situations this may come in handy.
- // case WildcardType => REFERENCE(ObjectClass)
- case norm => abort(
- "Unknown type: %s, %s [%s, %s] TypeRef? %s".format(
- t, norm, t.getClass, norm.getClass, t.isInstanceOf[TypeRef]
- )
- )
- }
-
- /** Return the type kind of a class, possibly an array type.
- */
- private def arrayOrClassType(sym: Symbol, targs: List[Type]) = sym match {
- case ArrayClass => ARRAY(toTypeKind(targs.head))
- case _ if sym.isClass => newReference(sym)
- case _ =>
- assert(sym.isType, sym) // it must be compiling Array[a]
- ObjectReference
- }
-
- /** Interfaces have to be handled delicately to avoid introducing
- * spurious errors, but if we treat them all as AnyRef we lose too
- * much information.
- */
- private def newReference(sym: Symbol): TypeKind = sym match {
- case NothingClass => NOTHING
- case NullClass => NULL
- case _ =>
- // Can't call .toInterface (at this phase) or we trip an assertion.
- // See PackratParser#grow for a method which fails with an apparent mismatch
- // between "object PackratParsers$class" and "trait PackratParsers"
- if (sym.isImplClass) {
- // pos/spec-List.scala is the sole failure if we don't check for NoSymbol
- val traitSym = sym.owner.info.decl(tpnme.interfaceName(sym.name))
- if (traitSym != NoSymbol)
- REFERENCE(traitSym)
- else
- REFERENCE(sym)
- } else {
- REFERENCE(sym)
- }
- }
-
- private def primitiveOrRefType(sym: Symbol) =
- primitiveTypeMap.getOrElse(sym, newReference(sym))
- private def primitiveOrClassType(sym: Symbol, targs: List[Type]) =
- primitiveTypeMap.getOrElse(sym, arrayOrClassType(sym, targs))
-}
generated by cgit v1.2.3 (git 2.39.1) at 2024-05-21 05:01:02 +0000