path: root/src/compiler/scala/reflect/internal/StdNames.scala

/* NSC -- new Scala compiler
 * Copyright 2005-2011 LAMP/EPFL
 * @author  Martin Odersky
 */

package scala.reflect
package internal

import scala.collection.immutable
import NameTransformer.MODULE_SUFFIX_STRING

trait StdNames extends /*reflect.generic.StdNames with*/ NameManglers { self: SymbolTable =>

  def encode(str: String): TermName = newTermName(NameTransformer.encode(str))

  implicit def stringToTermName(s: String): TermName = newTermName(s)

  /** This should be the first trait in the linearization. */
  trait Keywords {
    private var kws: Set[TermName] = Set()
    private def kw(s: String): TermName = {
      val result = newTermName(s)
      kws = kws + result
      result
    }

    final val ABSTRACTkw: TermName  = kw("abstract")
    final val CASEkw: TermName      = kw("case")
    final val CLASSkw: TermName     = kw("class")
    final val CATCHkw: TermName     = kw("catch")
    final val DEFkw: TermName       = kw("def")
    final val DOkw: TermName        = kw("do")
    final val ELSEkw: TermName      = kw("else")
    final val EXTENDSkw: TermName   = kw("extends")
    final val FALSEkw: TermName     = kw("false")
    final val FINALkw: TermName     = kw("final")
    final val FINALLYkw: TermName   = kw("finally")
    final val FORkw: TermName       = kw("for")
    final val FORSOMEkw: TermName   = kw("forSome")
    final val IFkw: TermName        = kw("if")
    final val IMPLICITkw: TermName  = kw("implicit")
    final val IMPORTkw: TermName    = kw("import")
    final val LAZYkw: TermName      = kw("lazy")
    final val MATCHkw: TermName     = kw("match")
    final val NEWkw: TermName       = kw("new")
    final val NULLkw: TermName      = kw("null")
    final val OBJECTkw: TermName    = kw("object")
    final val OVERRIDEkw: TermName  = kw("override")
    final val PACKAGEkw: TermName   = kw("package")
    final val PRIVATEkw: TermName   = kw("private")
    final val PROTECTEDkw: TermName = kw("protected")
    final val RETURNkw: TermName    = kw("return")
    final val SEALEDkw: TermName    = kw("sealed")
    final val SUPERkw: TermName     = kw("super")
    final val THISkw: TermName      = kw("this")
    final val THROWkw: TermName     = kw("throw")
    final val TRAITkw: TermName     = kw("trait")
    final val TRUEkw: TermName      = kw("true")
    final val TRYkw: TermName       = kw("try")
    final val TYPEkw: TermName      = kw("type")
    final val VALkw: TermName       = kw("val")
    final val VARkw: TermName       = kw("var")
    final val WITHkw: TermName      = kw("with")
    final val WHILEkw: TermName     = kw("while")
    final val YIELDkw: TermName     = kw("yield")
    final val DOTkw: TermName       = kw(".")
    final val USCOREkw: TermName    = kw("_")
    final val COLONkw: TermName     = kw(":")
    final val EQUALSkw: TermName    = kw("=")
    final val ARROWkw: TermName     = kw("=>")
    final val LARROWkw: TermName    = kw("<-")
    final val SUBTYPEkw: TermName   = kw("<:")
    final val VIEWBOUNDkw: TermName = kw("<%")
    final val SUPERTYPEkw: TermName = kw(">:")
    final val HASHkw: TermName      = kw("#")
    final val ATkw: TermName        = kw("@")

    final val keywords = {
      val result = kws.toSet
      kws = null
      result
    }

    final val javaKeywords = new JavaKeywords()
  }

  trait CommonNames /*extends LibraryCommonNames*/ {

    type NameType <: Name
    implicit def createNameType(name: String): NameType

    val EMPTY: NameType              = ""
    val ANON_FUN_NAME: NameType      = "$anonfun"
    val EMPTY_PACKAGE_NAME: NameType = "<empty>"
    val IMPORT: NameType             = "<import>"
    val MODULE_VAR_SUFFIX: NameType  = "$module"
    val ROOT: NameType               = "<root>"
    val PACKAGE: NameType            = "package"

    // value types (and AnyRef) are all used as terms as well
    // as (at least) arguments to the @specialize annotation.
    final val Boolean: NameType = "Boolean"
    final val Byte: NameType    = "Byte"
    final val Char: NameType    = "Char"
    final val Double: NameType  = "Double"
    final val Float: NameType   = "Float"
    final val Int: NameType     = "Int"
    final val Long: NameType    = "Long"
    final val Short: NameType   = "Short"
    final val Unit: NameType    = "Unit"

    final val ScalaValueNames: scala.List[NameType] =
      scala.List(Byte, Char, Short, Int, Long, Float, Double, Boolean, Unit)

    // some types whose companions we utilize
    final val AnyRef: NameType = "AnyRef"
    final val Array: NameType  = "Array"
    final val List: NameType   = "List"
    final val Seq: NameType    = "Seq"
    final val Symbol: NameType = "Symbol"

    // fictions we use as both types and terms
    final val ERROR: NameType    = "<error>"
    final val NO_NAME: NameType  = "<none>"  // formerly NOSYMBOL
    final val WILDCARD: NameType = "_"
  }

  trait TypeNames extends CommonNames {
    final val BYNAME_PARAM_CLASS_NAME: NameType        = "<byname>"
    final val EQUALS_PATTERN_NAME: NameType            = "<equals>"
    final val JAVA_REPEATED_PARAM_CLASS_NAME: NameType = "<repeated...>"
    final val LOCAL_CHILD: NameType                    = "<local child>"
    final val REPEATED_PARAM_CLASS_NAME: NameType      = "<repeated>"
    final val WILDCARD_STAR: NameType                  = "_*"

    final val Any: NameType             = "Any"
    final val AnyVal: NameType          = "AnyVal"
    final val Nothing: NameType         = "Nothing"
    final val Null: NameType            = "Null"
    final val Object: NameType          = "Object"
    final val PartialFunction: NameType = "PartialFunction"
    final val Product: NameType         = "Product"
    final val ScalaObject: NameType     = "ScalaObject"
    final val Serializable: NameType    = "Serializable"
    final val Singleton: NameType       = "Singleton"
    final val String: NameType          = "String"
    final val Throwable: NameType       = "Throwable"

    // Annotation types
    final val AnnotationDefaultATTR: NameType      = "AnnotationDefault"
    final val BridgeATTR: NameType                 = "Bridge"
    final val ClassfileAnnotationATTR: NameType    = "RuntimeInvisibleAnnotations" // RetentionPolicy.CLASS. Currently not used (Apr 2009).
    final val CodeATTR: NameType                   = "Code"
    final val ConstantValueATTR: NameType          = "ConstantValue"
    final val DeprecatedATTR: NameType             = "Deprecated"
    final val ExceptionsATTR: NameType             = "Exceptions"
    final val InnerClassesATTR: NameType           = "InnerClasses"
    final val JacoMetaATTR: NameType               = "JacoMeta"
    final val LineNumberTableATTR: NameType        = "LineNumberTable"
    final val LocalVariableTableATTR: NameType     = "LocalVariableTable"
    final val RuntimeAnnotationATTR: NameType      = "RuntimeVisibleAnnotations"   // RetentionPolicy.RUNTIME
    final val RuntimeParamAnnotationATTR: NameType = "RuntimeVisibleParameterAnnotations" // RetentionPolicy.RUNTIME (annotations on parameters)
    final val ScalaATTR: NameType                  = "Scala"
    final val ScalaSignatureATTR: NameType         = "ScalaSig"
    final val SignatureATTR: NameType              = "Signature"
    final val SourceFileATTR: NameType             = "SourceFile"
    final val SyntheticATTR: NameType              = "Synthetic"
  }


  trait TermNames extends Keywords with CommonNames {
    // Compiler internal names
    val ANYNAME: NameType               = "<anyname>"
    val CONSTRUCTOR: NameType           = "<init>"
    val FAKE_LOCAL_THIS: NameType       = "this$"
    val INITIALIZER: NameType           = CONSTRUCTOR // Is this buying us something?
    val MIXIN_CONSTRUCTOR: NameType     = "$init$"
    val MODULE_INSTANCE_FIELD: NameType = NameTransformer.MODULE_INSTANCE_NAME  // "MODULE$"
    val OUTER: NameType                 = "$outer"
    val OUTER_LOCAL: NameType           = "$outer " // note the space
    val SELF: NameType                  = "$this"
    val SPECIALIZED_INSTANCE: NameType  = "specInstance$"
    val STAR: NameType                  = "*"
    val THIS: NameType                  = "_$this"

    final val Nil: NameType             = "Nil"
    final val Predef: NameType          = "Predef"
    final val ScalaRunTime: NameType    = "ScalaRunTime"
    final val Some: NameType            = "Some"

    // Compiler utilized names
    // val productElementName: NameType = "productElementName"
    val TYPE_ : NameType           = "TYPE"
    val add_ : NameType            = "add"
    val anyValClass: NameType      = "anyValClass"
    val apply: NameType            = "apply"
    val arrayValue: NameType       = "arrayValue"
    val arraycopy: NameType        = "arraycopy"
    val asInstanceOf_ : NameType   = "asInstanceOf"
    val assert_ : NameType         = "assert"
    val assume_ : NameType         = "assume"
    val box: NameType              = "box"
    val bytes: NameType            = "bytes"
    val canEqual_ : NameType       = "canEqual"
    val checkInitialized: NameType = "checkInitialized"
    val classOf: NameType          = "classOf"
    val clone_ : NameType          = if (forMSIL) "MemberwiseClone" else "clone" // sn.OClone causes checkinit failure
    val conforms: NameType         = "conforms"
    val copy: NameType             = "copy"
    val delayedInit: NameType      = "delayedInit"
    val delayedInitArg: NameType   = "delayedInit$body"
    val drop: NameType             = "drop"
    val elem: NameType             = "elem"
    val eq: NameType               = "eq"
    val equals_ : NameType         = if (forMSIL) "Equals" else "equals"
    val error: NameType            = "error"
    val ex: NameType               = "ex"
    val false_ : NameType          = "false"
    val filter: NameType           = "filter"
    val finalize_ : NameType       = if (forMSIL) "Finalize" else "finalize"
    val find_ : NameType           = "find"
    val flatMap: NameType          = "flatMap"
    val foreach: NameType          = "foreach"
    val genericArrayOps: NameType  = "genericArrayOps"
    val get: NameType              = "get"
    val hasNext: NameType          = "hasNext"
    val hashCode_ : NameType       = if (forMSIL) "GetHashCode" else "hashCode"
    val hash_ : NameType           = "hash"
    val head: NameType             = "head"
    val identity: NameType         = "identity"
    val inlinedEquals: NameType    = "inlinedEquals"
    val applyDynamic: NameType     = "applyDynamic"
    val isArray: NameType          = "isArray"
    val isDefinedAt: NameType      = "isDefinedAt"
    val isEmpty: NameType          = "isEmpty"
    val isInstanceOf_ : NameType   = "isInstanceOf"
    val java: NameType             = "java"
    val lang: NameType             = "lang"
    val length: NameType           = "length"
    val lengthCompare: NameType    = "lengthCompare"
    val lift_ : NameType           = "lift"
    val main: NameType             = "main"
    val map: NameType              = "map"
    val ne: NameType               = "ne"
    val newArray: NameType         = "newArray"
    val next: NameType             = "next"
    val notifyAll_ : NameType      = "notifyAll"
    val notify_ : NameType         = "notify"
    val null_ : NameType           = "null"
    val ofDim: NameType            = "ofDim"
    val productArity: NameType     = "productArity"
    val productElement: NameType   = "productElement"
    val productIterator: NameType  = "productIterator"
    val productPrefix: NameType    = "productPrefix"
    val readResolve: NameType      = "readResolve"
    val sameElements: NameType     = "sameElements"
    val scala_ : NameType          = "scala"
    val self: NameType             = "self"
    val setAccessible: NameType    = "setAccessible"
    val synchronized_ : NameType   = "synchronized"
    val tail: NameType             = "tail"
    val this_ : NameType           = "this"
    val throw_ : NameType          = "throw"
    val toArray: NameType          = "toArray"
    val toList: NameType           = "toList"
    val toSeq: NameType            = "toSeq"
    val toString_ : NameType       = if (forMSIL) "ToString" else "toString"
    val true_ : NameType           = "true"
    val unapply: NameType          = "unapply"
    val unapplySeq: NameType       = "unapplySeq"
    val unbox: NameType            = "unbox"
    val update: NameType           = "update"
    val value: NameType            = "value"
    val view_ : NameType           = "view"
    val wait_ : NameType           = "wait"
    val withFilter: NameType       = "withFilter"
    val wrapRefArray: NameType     = "wrapRefArray"
    val zip: NameType              = "zip"

    // unencoded operators
    object raw {
      final val AMP  : NameType  = "&"
      final val BANG : NameType  = "!"
      final val BAR  : NameType  = "|"
      final val DOLLAR: NameType = "$"
      final val GE: NameType     = ">="
      final val LE: NameType     = "<="
      final val MINUS: NameType  = "-"
      final val NE: NameType     = "!="
      final val PLUS : NameType  = "+"
      final val SLASH: NameType  = "/"
      final val STAR : NameType  = "*"
      final val TILDE: NameType  = "~"

      final val isUnary: Set[Name] = Set(MINUS, PLUS, TILDE, BANG)
    }

    // value-conversion methods
    val toByte: NameType   = "toByte"
    val toShort: NameType  = "toShort"
    val toChar: NameType   = "toChar"
    val toInt: NameType    = "toInt"
    val toLong: NameType   = "toLong"
    val toFloat: NameType  = "toFloat"
    val toDouble: NameType = "toDouble"
  }

  object tpnme extends TypeNames /*with LibraryTypeNames*/ with TypeNameMangling {
    type NameType = TypeName
    implicit def createNameType(name: String): TypeName = newTypeName(name)

    val REFINE_CLASS_NAME: NameType  = "<refinement>"
    val ANON_CLASS_NAME: NameType    = "$anon"
  }

  val javanme = nme.javaKeywords

  object nme extends TermNames /*with LibraryTermNames*/ with TermNameMangling {
    type NameType = TermName
    def createNameType(name: String): TermName = newTermName(name)

    /** Translate a String into a list of simple TypeNames and TermNames.
     *  In all segments before the last, type/term is determined by whether
     *  the following separator char is '.' or '#'.  In the last segment,
     *  the argument "assumeTerm" determines it.  Examples:
     *
     *  package foo {
     *    object Lorax { object Wog ; class Wog }
     *    class Lorax  { object Zax ; class Zax }
     *  }
     *
     *  f("foo.Lorax", true)   == List("foo": Term, "Lorax": Term) // object Lorax
     *  f("foo.Lorax", false)  == List("foo": Term, "Lorax": Type) // class Lorax
     *  f("Lorax.Wog", true)   == List("Lorax": Term, "Wog": Term) // object Wog
     *  f("Lorax.Wog", false)  == List("Lorax": Term, "Wog": Type) // class Wog
     *  f("Lorax#Zax", true)   == List("Lorax": Type, "Zax": Term) // object Zax
     *  f("Lorax#Zax", false)  == List("Lorax": Type, "Zax": Type) // class Zax
     *
     *  Note that in actual scala syntax you cannot refer to object Zax without an
     *  instance of Lorax, so Lorax#Zax could only mean the type.  One might think
     *  that Lorax#Zax.type would work, but this is not accepted by the parser.
     *  For the purposes of referencing that object, the syntax is allowed.
     */
    def segments(name: String, assumeTerm: Boolean): List[Name] = {
      def mkName(str: String, term: Boolean): Name =
        if (term) newTermName(str) else newTypeName(str)

      name.indexWhere(ch => ch == '.' || ch == '#') match {
        // it's the last segment: the parameter tells us whether type or term
        case -1     => if (name == "") scala.Nil else scala.List(mkName(name, assumeTerm))
        // otherwise, we can tell based on whether '#' or '.' is the following char.
        case idx    =>
          val (simple, div, rest) = (name take idx, name charAt idx, name drop (idx + 1))
          mkName(simple, div == '.') :: segments(rest, assumeTerm)
      }
    }
    private def bitmapName(n: Int, suffix: String): TermName =
      newTermName(BITMAP_PREFIX + suffix + n)

    /** The name of bitmaps for initialized (public or protected) lazy vals. */
    def bitmapName(n: Int): TermName = bitmapName(n, "")

    /** The name of bitmaps for initialized transient lazy vals. */
    def bitmapNameForTransient(n: Int): TermName = bitmapName(n, "trans$")

    /** The name of bitmaps for initialized private lazy vals. */
    def bitmapNameForPrivate(n: Int): TermName = bitmapName(n, "priv$")

    /** The name of bitmaps for checkinit values */
    def bitmapNameForCheckinit(n: Int): TermName = bitmapName(n, "init$")

    /** The name of bitmaps for checkinit values that have transient flag*/
    def bitmapNameForCheckinitTransient(n: Int): TermName = bitmapName(n, "inittrans$")

    /** The expanded name of `name` relative to this class `base` with given `separator`
     */
    def expandedName(name: TermName, base: Symbol, separator: String = EXPAND_SEPARATOR_STRING): TermName =
      newTermName(base.fullName('$') + separator + name)

    def moduleVarName(name: TermName): TermName = newTermName("" + name + MODULE_VAR_SUFFIX)

    val EXPAND_SEPARATOR_STRING = "$$"
    val LOCAL_SUFFIX_STRING     = " "
    val ROOTPKG: TermName       = "_root_"

    /** Base strings from which synthetic names are derived. */
    val BITMAP_PREFIX               = "bitmap$"
    val CHECK_IF_REFUTABLE_STRING   = "check$ifrefutable$"
    val DEFAULT_GETTER_STRING       = "$default$"
    val DO_WHILE_PREFIX             = "doWhile$"
    val EQEQ_LOCAL_VAR              = "eqEqTemp$"
    val EVIDENCE_PARAM_PREFIX       = "evidence$"
    val EXCEPTION_RESULT_PREFIX     = "exceptionResult"
    val INTERPRETER_IMPORT_WRAPPER  = "$iw"
    val INTERPRETER_LINE_PREFIX     = "line"
    val INTERPRETER_VAR_PREFIX      = "res"
    val INTERPRETER_WRAPPER_SUFFIX  = "$object"
    val WHILE_PREFIX                = "while$"

    def getCause   = sn.GetCause
    def getClass_  = sn.GetClass
    def getMethod_ = sn.GetMethod
    def invoke_    = sn.Invoke

    val ADD      = encode("+")
    val AND      = encode("&")
    val ASR      = encode(">>")
    val DIV      = encode("/")
    val EQ       = encode("==")
    val EQL      = encode("=")
    val GE       = encode(">=")
    val GT       = encode(">")
    val HASHHASH = encode("##")
    val LE       = encode("<=")
    val LSL      = encode("<<")
    val LSR      = encode(">>>")
    val LT       = encode("<")
    val MINUS    = encode("-")
    val MOD      = encode("%")
    val MUL      = encode("*")
    val NE       = encode("!=")
    val OR       = encode("|")
    val PLUS     = encode("+")
    val SUB      = encode("-")
    val XOR      = encode("^")
    val ZAND     = encode("&&")
    val ZOR      = encode("||")

    // unary operators
    val UNARY_~ = encode("unary_~")
    val UNARY_+ = encode("unary_+")
    val UNARY_- = encode("unary_-")
    val UNARY_! = encode("unary_!")
  }

  abstract class SymbolNames {
    protected implicit def stringToTypeName(s: String): TypeName = newTypeName(s)

    val BeanProperty        : TypeName
    val BooleanBeanProperty : TypeName
    val BoxedBoolean        : TypeName
    val BoxedCharacter      : TypeName
    val BoxedNumber         : TypeName
    val Class               : TypeName
    val Code                : TypeName
    val Delegate            : TypeName
    val IOOBException       : TypeName // IndexOutOfBoundsException
    val InvTargetException  : TypeName // InvocationTargetException
    val JavaSerializable    : TypeName
    val MethodAsObject      : TypeName
    val NPException         : TypeName // NullPointerException
    val Object              : TypeName
    val String              : TypeName
    val Throwable           : TypeName
    val ValueType           : TypeName

    val ForName             : TermName
    val GetCause            : TermName
    val GetClass            : TermName
    val GetMethod           : TermName
    val Invoke              : TermName
    val JavaLang            : TermName

    val Boxed: immutable.Map[TypeName, TypeName]
  }

  class JavaKeywords {
    private var kws: Set[TermName] = Set()
    private def kw(s: String): TermName = {
      val result = newTermName(s)
      kws = kws + result
      result
    }

    final val ABSTRACTkw: TermName     = kw("abstract")
    final val ASSERTkw: TermName       = kw("assert")
    final val BOOLEANkw: TermName      = kw("boolean")
    final val BREAKkw: TermName        = kw("break")
    final val BYTEkw: TermName         = kw("byte")
    final val CASEkw: TermName         = kw("case")
    final val CATCHkw: TermName        = kw("catch")
    final val CHARkw: TermName         = kw("char")
    final val CLASSkw: TermName        = kw("class")
    final val CONSTkw: TermName        = kw("const")
    final val CONTINUEkw: TermName     = kw("continue")
    final val DEFAULTkw: TermName      = kw("default")
    final val DOkw: TermName           = kw("do")
    final val DOUBLEkw: TermName       = kw("double")
    final val ELSEkw: TermName         = kw("else")
    final val ENUMkw: TermName         = kw("enum")
    final val EXTENDSkw: TermName      = kw("extends")
    final val FINALkw: TermName        = kw("final")
    final val FINALLYkw: TermName      = kw("finally")
    final val FLOATkw: TermName        = kw("float")
    final val FORkw: TermName          = kw("for")
    final val IFkw: TermName           = kw("if")
    final val GOTOkw: TermName         = kw("goto")
    final val IMPLEMENTSkw: TermName   = kw("implements")
    final val IMPORTkw: TermName       = kw("import")
    final val INSTANCEOFkw: TermName   = kw("instanceof")
    final val INTkw: TermName          = kw("int")
    final val INTERFACEkw: TermName    = kw("interface")
    final val LONGkw: TermName         = kw("long")
    final val NATIVEkw: TermName       = kw("native")
    final val NEWkw: TermName          = kw("new")
    final val PACKAGEkw: TermName      = kw("package")
    final val PRIVATEkw: TermName      = kw("private")
    final val PROTECTEDkw: TermName    = kw("protected")
    final val PUBLICkw: TermName       = kw("public")
    final val RETURNkw: TermName       = kw("return")
    final val SHORTkw: TermName        = kw("short")
    final val STATICkw: TermName       = kw("static")
    final val STRICTFPkw: TermName     = kw("strictfp")
    final val SUPERkw: TermName        = kw("super")
    final val SWITCHkw: TermName       = kw("switch")
    final val SYNCHRONIZEDkw: TermName = kw("synchronized")
    final val THISkw: TermName         = kw("this")
    final val THROWkw: TermName        = kw("throw")
    final val THROWSkw: TermName       = kw("throws")
    final val TRANSIENTkw: TermName    = kw("transient")
    final val TRYkw: TermName          = kw("try")
    final val VOIDkw: TermName         = kw("void")
    final val VOLATILEkw: TermName     = kw("volatile")
    final val WHILEkw: TermName        = kw("while")

    final val keywords = {
      val result = kws.toSet
      kws = null
      result
    }
  }

  private abstract class JavaNames extends SymbolNames {
    final val BoxedBoolean: TypeName       = "java.lang.Boolean"
    final val BoxedByte: TypeName          = "java.lang.Byte"
    final val BoxedCharacter: TypeName     = "java.lang.Character"
    final val BoxedDouble: TypeName        = "java.lang.Double"
    final val BoxedFloat: TypeName         = "java.lang.Float"
    final val BoxedInteger: TypeName       = "java.lang.Integer"
    final val BoxedLong: TypeName          = "java.lang.Long"
    final val BoxedNumber: TypeName        = "java.lang.Number"
    final val BoxedShort: TypeName         = "java.lang.Short"
    final val Class: TypeName              = "java.lang.Class"
    final val Delegate: TypeName           = tpnme.NO_NAME
    final val IOOBException: TypeName      = "java.lang.IndexOutOfBoundsException"
    final val InvTargetException: TypeName = "java.lang.reflect.InvocationTargetException"
    final val MethodAsObject: TypeName     = "java.lang.reflect.Method"
    final val NPException: TypeName        = "java.lang.NullPointerException"
    final val Object: TypeName             = "java.lang.Object"
    final val String: TypeName             = "java.lang.String"
    final val Throwable: TypeName          = "java.lang.Throwable"
    final val ValueType: TypeName          = tpnme.NO_NAME

    final val ForName: TermName   = "forName"
    final val GetCause: TermName  = "getCause"
    final val GetClass: TermName  = "getClass"
    final val GetMethod: TermName = "getMethod"
    final val Invoke: TermName    = "invoke"
    final val JavaLang: TermName  = "java.lang"

    val Boxed = immutable.Map[TypeName, TypeName](
      tpnme.Boolean -> BoxedBoolean,
      tpnme.Byte    -> BoxedByte,
      tpnme.Char    -> BoxedCharacter,
      tpnme.Short   -> BoxedShort,
      tpnme.Int     -> BoxedInteger,
      tpnme.Long    -> BoxedLong,
      tpnme.Float   -> BoxedFloat,
      tpnme.Double  -> BoxedDouble
    )
  }

  private class MSILNames extends SymbolNames {
    final val BeanProperty: TypeName        = tpnme.NO_NAME
    final val BooleanBeanProperty: TypeName = tpnme.NO_NAME
    final val BoxedBoolean: TypeName        = "System.IConvertible"
    final val BoxedCharacter: TypeName      = "System.IConvertible"
    final val BoxedNumber: TypeName         = "System.IConvertible"
    final val Class: TypeName               = "System.Type"
    final val Code: TypeName                = tpnme.NO_NAME
    final val Delegate: TypeName            = "System.MulticastDelegate"
    final val IOOBException: TypeName       = "System.IndexOutOfRangeException"
    final val InvTargetException: TypeName  = "System.Reflection.TargetInvocationException"
    final val JavaSerializable: TypeName    = tpnme.NO_NAME
    final val MethodAsObject: TypeName      = "System.Reflection.MethodInfo"
    final val NPException: TypeName         = "System.NullReferenceException"
    final val Object: TypeName              = "System.Object"
    final val String: TypeName              = "System.String"
    final val Throwable: TypeName           = "System.Exception"
    final val ValueType: TypeName           = "System.ValueType"

    final val ForName: TermName   = "GetType"
    final val GetCause: TermName  = "InnerException" /* System.Reflection.TargetInvocationException.InnerException */
    final val GetClass: TermName  = "GetType"
    final val GetMethod: TermName = "GetMethod"
    final val Invoke: TermName    = "Invoke"
    final val JavaLang: TermName  = "System"

    val Boxed = immutable.Map[TypeName, TypeName](
      tpnme.Boolean -> "System.Boolean",
      tpnme.Byte    -> "System.SByte", // a scala.Byte is signed and a System.SByte too (unlike a System.Byte)
      tpnme.Char    -> "System.Char",
      tpnme.Short   -> "System.Int16",
      tpnme.Int     -> "System.Int32",
      tpnme.Long    -> "System.Int64",
      tpnme.Float   -> "System.Single",
      tpnme.Double  -> "System.Double"
    )
  }

  private class J2SENames extends JavaNames {
    final val BeanProperty: TypeName        = "scala.beans.BeanProperty"
    final val BooleanBeanProperty: TypeName = "scala.beans.BooleanBeanProperty"
    final val Code: TypeName                = "scala.reflect.Code"
    final val JavaSerializable: TypeName    = "java.io.Serializable"
  }

  lazy val sn: SymbolNames =
    if (forMSIL) new MSILNames
    else new J2SENames
}