|
Scala example source code file (StdNames.scala)
The StdNames.scala Scala example source code/* NSC -- new Scala compiler * Copyright 2005-2013 LAMP/EPFL * @author Martin Odersky */ package scala package reflect package internal import java.security.MessageDigest import java.util.UUID.randomUUID import Chars.isOperatorPart import scala.annotation.switch import scala.language.implicitConversions import scala.collection.immutable import scala.io.Codec trait StdNames { self: SymbolTable => def encode(str: String): TermName = newTermNameCached(NameTransformer.encode(str)) /** Tensions: would like the keywords to be the very first names entered into the names * storage so their ids count from 0, which simplifies the parser. Switched to abstract * classes to avoid all the indirection which is generated with implementation-containing * traits. Since all these classes use eager vals, that means the constructor with the * keywords must run first. If it's the top in the superclass chain, then CommonNames * must inherit from it, which means TypeNames would inherit keywords as well. * * Solution: Keywords extends CommonNames and uses early defs to beat the * CommonNames constructor out of the starting gate. This is its builder. */ private class KeywordSetBuilder { private var kws: Set[TermName] = Set() def apply(s: String): TermName = { val result = newTermNameCached(s) kws = kws + result result } def result: Set[TermName] = try kws finally kws = null } private[reflect] def compactifyName(orig: String): String = compactify(orig) private final object compactify extends (String => String) { val md5 = MessageDigest.getInstance("MD5") /** * COMPACTIFY * * The hashed name has the form (prefix + marker + md5 + marker + suffix), where * - prefix/suffix.length = MaxNameLength / 4 * - md5.length = 32 * * We obtain the formula: * * FileNameLength = 2*(MaxNameLength / 4) + 2.marker.length + 32 + suffixLength * * (+suffixLength for ".class" and potential module class suffix that is added *after* this transform). * * MaxNameLength can therefore be computed as follows: */ val marker = "$$$$" val maxSuffixLength = "$.class".length + 1 // potential module class suffix and file extension val MaxNameLength = math.min( settings.maxClassfileName.value - maxSuffixLength, 2 * (settings.maxClassfileName.value - maxSuffixLength - 2*marker.length - 32) ) def toMD5(s: String, edge: Int): String = { val prefix = s take edge val suffix = s takeRight edge val cs = s.toArray val bytes = Codec toUTF8 cs md5 update bytes val md5chars = (md5.digest() map (b => (b & 0xFF).toHexString)).mkString prefix + marker + md5chars + marker + suffix } def apply(s: String): String = ( if (s.length <= MaxNameLength) s else toMD5(s, MaxNameLength / 4) ) } abstract class CommonNames extends NamesApi { type NameType >: Null <: Name // Masking some implicits so as to allow our targeted => NameType. protected val stringToTermName = null protected val stringToTypeName = null protected implicit def createNameType(name: String): NameType def flattenedName(segments: Name*): NameType = compactify(segments mkString NAME_JOIN_STRING) val NAME_JOIN_STRING: String = NameTransformer.NAME_JOIN_STRING val MODULE_SUFFIX_STRING: String = NameTransformer.MODULE_SUFFIX_STRING val LOCAL_SUFFIX_STRING: String = NameTransformer.LOCAL_SUFFIX_STRING val TRAIT_SETTER_SEPARATOR_STRING: String = NameTransformer.TRAIT_SETTER_SEPARATOR_STRING val SINGLETON_SUFFIX: String = ".type" val ANON_CLASS_NAME: NameType = "$anon" val ANON_FUN_NAME: NameType = "$anonfun" val EMPTY: NameType = "" val EMPTY_PACKAGE_NAME: NameType = "<empty>" val IMPL_CLASS_SUFFIX = "$class" val IMPORT: NameType = "<import>" val MODULE_SUFFIX_NAME: NameType = MODULE_SUFFIX_STRING val MODULE_VAR_SUFFIX: NameType = "$module" val PACKAGE: NameType = "package" val ROOT: NameType = "<root>" val SPECIALIZED_SUFFIX: NameType = "$sp" // 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" // 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" final val WeakTypeTag: NameType = "WeakTypeTag" final val TypeTag : NameType = "TypeTag" final val Expr: NameType = "Expr" final val String: NameType = "String" final val StringContext: NameType = "StringContext" // 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 = "_" } /** This should be the first trait in the linearization. */ // abstract class Keywords extends CommonNames { abstract class Keywords extends { private val kw = new KeywordSetBuilder 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 MACROkw: TermName = kw("macro") 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 THENkw: TermName = kw("then") 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 = kw.result } with CommonNames { final val javaKeywords = new JavaKeywords() } abstract class TypeNames extends Keywords with TypeNamesApi { override type NameType = TypeName protected implicit def createNameType(name: String): TypeName = newTypeNameCached(name) final val BYNAME_PARAM_CLASS_NAME: NameType = "<byname>" final val JAVA_REPEATED_PARAM_CLASS_NAME: NameType = "<repeated...>" final val LOCAL_CHILD: NameType = "<local child>" final val REFINE_CLASS_NAME: NameType = "<refinement>" final val REPEATED_PARAM_CLASS_NAME: NameType = "<repeated>" final val WILDCARD_STAR: NameType = "_*" final val REIFY_TREECREATOR_PREFIX: NameType = "$treecreator" final val REIFY_TYPECREATOR_PREFIX: NameType = "$typecreator" final val MACRO_BUNDLE_SUFFIX: NameType = "$Bundle" final val Any: NameType = "Any" final val AnyVal: NameType = "AnyVal" final val FlagSet: NameType = "FlagSet" final val Mirror: NameType = "Mirror" final val Modifiers: NameType = "Modifiers" final val Nothing: NameType = "Nothing" final val Null: NameType = "Null" final val Object: NameType = "Object" final val PrefixType: NameType = "PrefixType" final val Product: NameType = "Product" final val Serializable: NameType = "Serializable" final val Singleton: NameType = "Singleton" final val Throwable: NameType = "Throwable" final val unchecked: NameType = "unchecked" final val api: NameType = "api" final val Annotation: NameType = "Annotation" final val CaseDef: NameType = "CaseDef" final val ClassfileAnnotation: NameType = "ClassfileAnnotation" final val ClassManifest: NameType = "ClassManifest" final val Enum: NameType = "Enum" final val Group: NameType = "Group" final val implicitNotFound: NameType = "implicitNotFound" final val Liftable: NameType = "Liftable" final val Unliftable: NameType = "Unliftable" final val Name: NameType = "Name" final val Tree: NameType = "Tree" final val TermName: NameType = "TermName" final val Type : NameType = "Type" final val TypeName: NameType = "TypeName" final val TypeDef: NameType = "TypeDef" final val Quasiquote: NameType = "Quasiquote" // quasiquote-specific names final val QUASIQUOTE_FUNCTION: NameType = "$quasiquote$function$" final val QUASIQUOTE_MODS: NameType = "$quasiquote$mods$" final val QUASIQUOTE_TUPLE: NameType = "$quasiquote$tuple$" // Annotation simple names, used in Namer final val BeanPropertyAnnot: NameType = "BeanProperty" final val BooleanBeanPropertyAnnot: NameType = "BooleanBeanProperty" final val bridgeAnnot: NameType = "bridge" // Classfile Attributes final val AnnotationDefaultATTR: NameType = "AnnotationDefault" final val BridgeATTR: NameType = "Bridge" 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 RuntimeAnnotationATTR: NameType = "RuntimeVisibleAnnotations" // RetentionPolicy.RUNTIME 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" final val scala_ : NameType = "scala" def dropSingletonName(name: Name): TypeName = (name dropRight SINGLETON_SUFFIX.length).toTypeName def singletonName(name: Name): TypeName = (name append SINGLETON_SUFFIX).toTypeName def implClassName(name: Name): TypeName = (name append IMPL_CLASS_SUFFIX).toTypeName def interfaceName(implname: Name): TypeName = (implname dropRight IMPL_CLASS_SUFFIX.length).toTypeName } abstract class TermNames extends Keywords with TermNamesApi { override type NameType = TermName protected implicit def createNameType(name: String): TermName = newTermNameCached(name) /** 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 DEFAULT_GETTER_INIT_STRING = NameTransformer.encode("<init>") + DEFAULT_GETTER_STRING val DO_WHILE_PREFIX = "doWhile$" val EVIDENCE_PARAM_PREFIX = "evidence$" val EXCEPTION_RESULT_PREFIX = "exceptionResult" val EXPAND_SEPARATOR_STRING = "$$" val FRESH_TERM_NAME_PREFIX = "x$" val INTERPRETER_IMPORT_WRAPPER = "$iw" val LOCALDUMMY_PREFIX = "<local " // owner of local blocks val PROTECTED_PREFIX = "protected$" val PROTECTED_SET_PREFIX = PROTECTED_PREFIX + "set" val SUPER_PREFIX_STRING = "super$" val WHILE_PREFIX = "while$" val FRESH_PREFIX = "fresh" val FRESH_SUFFIX = "macro$" // uses a keyword to avoid collisions with mangled names val QUAL_PREFIX = "qual$" val NAMEDARG_PREFIX = "x$" // Compiler internal names val ANYname: NameType = "<anyname>" val CONSTRUCTOR: NameType = "<init>" val DEFAULT_CASE: NameType = "defaultCase$" val EQEQ_LOCAL_VAR: NameType = "eqEqTemp$" val FAKE_LOCAL_THIS: NameType = "this$" val LAZY_LOCAL: NameType = "$lzy" val LAZY_SLOW_SUFFIX: NameType = "$lzycompute" val UNIVERSE_BUILD_PREFIX: NameType = "$u.internal.reificationSupport." val UNIVERSE_PREFIX: NameType = "$u." val UNIVERSE_SHORT: NameType = "$u" val MIRROR_PREFIX: NameType = "$m." val MIRROR_SHORT: NameType = "$m" val MIRROR_UNTYPED: NameType = "$m$untyped" val REIFY_FREE_PREFIX: NameType = "free$" val REIFY_FREE_THIS_SUFFIX: NameType = "$this" val REIFY_FREE_VALUE_SUFFIX: NameType = "$value" val REIFY_SYMDEF_PREFIX: NameType = "symdef$" val QUASIQUOTE_CASE: NameType = "$quasiquote$case$" val QUASIQUOTE_EARLY_DEF: NameType = "$quasiquote$early$def$" val QUASIQUOTE_FILE: String = "<quasiquote>" val QUASIQUOTE_FOR_ENUM: NameType = "$quasiquote$for$enum$" val QUASIQUOTE_NAME_PREFIX: String = "nn$" val QUASIQUOTE_PACKAGE_STAT: NameType = "$quasiquote$package$stat$" val QUASIQUOTE_PARAM: NameType = "$quasiquote$param$" val QUASIQUOTE_PAT_DEF: NameType = "$quasiquote$pat$def$" val QUASIQUOTE_PREFIX: String = "qq$" val QUASIQUOTE_REFINE_STAT: NameType = "$quasiquote$refine$stat$" val QUASIQUOTE_TUPLE: NameType = "$quasiquote$tuple$" val QUASIQUOTE_UNLIFT_HELPER: String = "$quasiquote$unlift$helper$" val MIXIN_CONSTRUCTOR: NameType = "$init$" val MODULE_INSTANCE_FIELD: NameType = NameTransformer.MODULE_INSTANCE_NAME // "MODULE$" val OUTER: NameType = "$outer" val OUTER_LOCAL: NameType = OUTER.localName val OUTER_SYNTH: NameType = "<outer>" // emitted by virtual pattern matcher, replaced by outer accessor in explicitouter val ROOTPKG: NameType = "_root_" val SELECTOR_DUMMY: NameType = "<unapply-selector>" val SELF: NameType = "$this" val SETTER_SUFFIX: NameType = NameTransformer.SETTER_SUFFIX_STRING val SPECIALIZED_INSTANCE: NameType = "specInstance$" val STAR: NameType = "*" val THIS: NameType = "_$this" def isConstructorName(name: Name) = name == CONSTRUCTOR || name == MIXIN_CONSTRUCTOR def isExceptionResultName(name: Name) = name startsWith EXCEPTION_RESULT_PREFIX def isImplClassName(name: Name) = name endsWith IMPL_CLASS_SUFFIX def isLocalDummyName(name: Name) = name startsWith LOCALDUMMY_PREFIX def isLocalName(name: Name) = name endsWith LOCAL_SUFFIX_STRING def isLoopHeaderLabel(name: Name) = (name startsWith WHILE_PREFIX) || (name startsWith DO_WHILE_PREFIX) def isProtectedAccessorName(name: Name) = name startsWith PROTECTED_PREFIX def isReplWrapperName(name: Name) = name containsName INTERPRETER_IMPORT_WRAPPER def isSetterName(name: Name) = name endsWith SETTER_SUFFIX def isTraitSetterName(name: Name) = isSetterName(name) && (name containsName TRAIT_SETTER_SEPARATOR_STRING) def isSingletonName(name: Name) = name endsWith SINGLETON_SUFFIX def isModuleName(name: Name) = name endsWith MODULE_SUFFIX_NAME /** Is name a variable name? */ def isVariableName(name: Name): Boolean = { val first = name.startChar ( ((first.isLower && first.isLetter) || first == '_') && (name != nme.false_) && (name != nme.true_) && (name != nme.null_) ) } def isOpAssignmentName(name: Name) = name match { case raw.NE | raw.LE | raw.GE | EMPTY => false case _ => name.endChar == '=' && name.startChar != '=' && isOperatorPart(name.startChar) } private def expandedNameInternal(name: TermName, base: Symbol, separator: String): TermName = newTermNameCached(base.fullName('$') + separator + name) /** The expanded name of `name` relative to this class `base` */ def expandedName(name: TermName, base: Symbol) = expandedNameInternal(name, base, EXPAND_SEPARATOR_STRING) /** The expanded setter name of `name` relative to this class `base` */ def expandedSetterName(name: TermName, base: Symbol) = expandedNameInternal(name, base, TRAIT_SETTER_SEPARATOR_STRING) /** If `name` is an expandedName name, the original (unexpanded) name. * Otherwise `name` itself. * Look backward from the end of the string for "$$", and take the * part of the string after that; but if the string is "$$$" or longer, * be sure to retain the extra dollars. */ def unexpandedName(name: Name): Name = name lastIndexOf "$$" match { case 0 | -1 => name case idx0 => // Sketchville - We've found $$ but if it's part of $$$ or $$$$ // or something we need to keep the bonus dollars, so e.g. foo$$$outer // has an original name of $outer. var idx = idx0 while (idx > 0 && name.charAt(idx - 1) == '$') idx -= 1 name drop idx + 2 } @deprecated("Use unexpandedName", "2.11.0") def originalName(name: Name): Name = unexpandedName(name) @deprecated("Use Name#dropModule", "2.11.0") def stripModuleSuffix(name: Name): Name = name.dropModule @deprecated("Use Name#dropLocal", "2.11.0") def localToGetter(name: TermName): TermName = name.dropLocal @deprecated("Use Name#dropLocal", "2.11.0") def dropLocalSuffix(name: Name): TermName = name.dropLocal @deprecated("Use Name#localName", "2.11.0") def getterToLocal(name: TermName): TermName = name.localName @deprecated("Use Name#setterName", "2.11.0") def getterToSetter(name: TermName): TermName = name.setterName @deprecated("Use Name#getterName", "2.11.0") def getterName(name: TermName): TermName = name.getterName @deprecated("Use Name#getterName", "2.11.0") def setterToGetter(name: TermName): TermName = name.getterName /** * Convert `Tuple2$mcII` to `Tuple2`, or `T1$sp` to `T1`. */ def unspecializedName(name: Name): Name = ( // DUPLICATED LOGIC WITH `splitSpecializedName` if (name endsWith SPECIALIZED_SUFFIX) name.subName(0, name.lastIndexOf('m') - 1) else name ) /** Return the original name and the types on which this name * is specialized. For example, * {{{ * splitSpecializedName("foo$mIcD$sp") == ('foo', "D", "I") * }}} * `foo$mIcD$sp` is the name of a method specialized on two type * parameters, the first one belonging to the method itself, on Int, * and another one belonging to the enclosing class, on Double. * * @return (unspecializedName, class tparam specializations, method tparam specializations) */ def splitSpecializedName(name: Name): (Name, String, String) = // DUPLICATED LOGIC WITH `unspecializedName` if (name endsWith SPECIALIZED_SUFFIX) { val name1 = name dropRight SPECIALIZED_SUFFIX.length val idxC = name1 lastIndexOf 'c' val idxM = name1 lastIndexOf 'm' (name1.subName(0, idxM - 1), name1.subName(idxC + 1, name1.length).toString, name1.subName(idxM + 1, idxC).toString) } else (name, "", "") // Nominally, name$default$N, encoded for <init> def defaultGetterName(name: Name, pos: Int): TermName = ( if (isConstructorName(name)) DEFAULT_GETTER_INIT_STRING + pos else name + DEFAULT_GETTER_STRING + pos ) // Nominally, name from name$default$N, CONSTRUCTOR for <init> def defaultGetterToMethod(name: Name): TermName = ( if (name startsWith DEFAULT_GETTER_INIT_STRING) nme.CONSTRUCTOR else name indexOf DEFAULT_GETTER_STRING match { case -1 => name.toTermName case idx => name.toTermName take idx } ) def localDummyName(clazz: Symbol): TermName = newTermName(LOCALDUMMY_PREFIX + clazz.name + ">") def superName(name: Name): TermName = newTermName(SUPER_PREFIX_STRING + name) /** The name of an accessor for protected symbols. */ def protName(name: Name): TermName = newTermName(PROTECTED_PREFIX + name) /** The name of a setter for protected symbols. Used for inherited Java fields. */ def protSetterName(name: Name): TermName = newTermName(PROTECTED_SET_PREFIX + name) final val Nil: NameType = "Nil" final val Predef: NameType = "Predef" val _1 : NameType = "_1" val _2 : NameType = "_2" val _3 : NameType = "_3" val _4 : NameType = "_4" val _5 : NameType = "_5" val _6 : NameType = "_6" val _7 : NameType = "_7" val _8 : NameType = "_8" val _9 : NameType = "_9" val _10 : NameType = "_10" val _11 : NameType = "_11" val _12 : NameType = "_12" val _13 : NameType = "_13" val _14 : NameType = "_14" val _15 : NameType = "_15" val _16 : NameType = "_16" val _17 : NameType = "_17" val _18 : NameType = "_18" val _19 : NameType = "_19" val _20 : NameType = "_20" val _21 : NameType = "_21" val _22 : NameType = "_22" val x_0 : NameType = "x$0" val x_1 : NameType = "x$1" val x_2 : NameType = "x$2" val x_3 : NameType = "x$3" val x_4 : NameType = "x$4" val x_5 : NameType = "x$5" val x_6 : NameType = "x$6" val x_7 : NameType = "x$7" val x_8 : NameType = "x$8" val x_9 : NameType = "x$9" @switch def syntheticParamName(i: Int): TermName = i match { case 0 => nme.x_0 case 1 => nme.x_1 case 2 => nme.x_2 case 3 => nme.x_3 case 4 => nme.x_4 case 5 => nme.x_5 case 6 => nme.x_6 case 7 => nme.x_7 case 8 => nme.x_8 case 9 => nme.x_9 case _ => newTermName("x$" + i) } @switch def productAccessorName(j: Int): TermName = j match { case 1 => nme._1 case 2 => nme._2 case 3 => nme._3 case 4 => nme._4 case 5 => nme._5 case 6 => nme._6 case 7 => nme._7 case 8 => nme._8 case 9 => nme._9 case 10 => nme._10 case 11 => nme._11 case 12 => nme._12 case 13 => nme._13 case 14 => nme._14 case 15 => nme._15 case 16 => nme._16 case 17 => nme._17 case 18 => nme._18 case 19 => nme._19 case 20 => nme._20 case 21 => nme._21 case 22 => nme._22 case _ => newTermName("_" + j) } val ??? = encode("???") val wrapRefArray: NameType = "wrapRefArray" val wrapByteArray: NameType = "wrapByteArray" val wrapShortArray: NameType = "wrapShortArray" val wrapCharArray: NameType = "wrapCharArray" val wrapIntArray: NameType = "wrapIntArray" val wrapLongArray: NameType = "wrapLongArray" val wrapFloatArray: NameType = "wrapFloatArray" val wrapDoubleArray: NameType = "wrapDoubleArray" val wrapBooleanArray: NameType = "wrapBooleanArray" val wrapUnitArray: NameType = "wrapUnitArray" val genericWrapArray: NameType = "genericWrapArray" // Compiler utilized names val AnnotatedType: NameType = "AnnotatedType" val Annotation: NameType = "Annotation" val Any: NameType = "Any" val AnyVal: NameType = "AnyVal" val Apply: NameType = "Apply" val ArrayAnnotArg: NameType = "ArrayAnnotArg" val CaseDef: NameType = "CaseDef" val ClassInfoType: NameType = "ClassInfoType" val ConstantType: NameType = "ConstantType" val EmptyPackage: NameType = "EmptyPackage" val EmptyPackageClass: NameType = "EmptyPackageClass" val ExistentialType: NameType = "ExistentialType" val Flag : NameType = "Flag" val FlagsRepr: NameType = "FlagsRepr" val Ident: NameType = "Ident" val ImplicitParams: NameType = "ImplicitParams" val Import: NameType = "Import" val Literal: NameType = "Literal" val LiteralAnnotArg: NameType = "LiteralAnnotArg" val MethodType: NameType = "MethodType" val Modifiers: NameType = "Modifiers" val NestedAnnotArg: NameType = "NestedAnnotArg" val New: NameType = "New" val NoFlags: NameType = "NoFlags" val NoSymbol: NameType = "NoSymbol" val NoMods: NameType = "NoMods" val Nothing: NameType = "Nothing" val Null: NameType = "Null" val NullaryMethodType: NameType = "NullaryMethodType" val Object: NameType = "Object" val PolyType: NameType = "PolyType" val RefinedType: NameType = "RefinedType" val RootPackage: NameType = "RootPackage" val RootClass: NameType = "RootClass" val Select: NameType = "Select" val SelectFromTypeTree: NameType = "SelectFromTypeTree" val SingleType: NameType = "SingleType" val SuperType: NameType = "SuperType" val This: NameType = "This" val ThisType: NameType = "ThisType" val Tuple2: NameType = "Tuple2" val TYPE_ : NameType = "TYPE" val TypeBounds: NameType = "TypeBounds" val TypeRef: NameType = "TypeRef" val TypeTree: NameType = "TypeTree" val UNIT : NameType = "UNIT" val accessor: NameType = "accessor" val add_ : NameType = "add" val annotation: NameType = "annotation" val anyValClass: NameType = "anyValClass" val apply: NameType = "apply" val applyDynamic: NameType = "applyDynamic" val applyDynamicNamed: NameType = "applyDynamicNamed" val applyOrElse: NameType = "applyOrElse" val args : NameType = "args" val arrayClass: NameType = "arrayClass" val array_apply : NameType = "array_apply" val array_clone : NameType = "array_clone" val array_length : NameType = "array_length" val array_update : NameType = "array_update" val asModule: NameType = "asModule" val asType: NameType = "asType" val asInstanceOf_ : NameType = "asInstanceOf" val asInstanceOf_Ob : NameType = "$asInstanceOf" val box: NameType = "box" val bytes: NameType = "bytes" val c: NameType = "c" val canEqual_ : NameType = "canEqual" val classOf: NameType = "classOf" val clone_ : NameType = "clone" val collection: NameType = "collection" val conforms: NameType = "$conforms" // dollar prefix to avoid accidental shadowing val copy: NameType = "copy" val create: NameType = "create" val currentMirror: NameType = "currentMirror" val delayedInit: NameType = "delayedInit" val delayedInitArg: NameType = "delayedInit$body" val dollarScope: NameType = "$scope" val drop: NameType = "drop" val elem: NameType = "elem" val noSelfType: NameType = "noSelfType" val ensureAccessible : NameType = "ensureAccessible" val eq: NameType = "eq" val equalsNumChar : NameType = "equalsNumChar" val equalsNumNum : NameType = "equalsNumNum" val equalsNumObject : NameType = "equalsNumObject" val equals_ : NameType = "equals" val error: NameType = "error" val ex: NameType = "ex" val experimental: NameType = "experimental" val f: NameType = "f" val false_ : NameType = "false" val filter: NameType = "filter" val finalize_ : NameType = "finalize" val find_ : NameType = "find" val flatMap: NameType = "flatMap" val foreach: NameType = "foreach" val freshTermName: NameType = "freshTermName" val freshTypeName: NameType = "freshTypeName" val get: NameType = "get" val hashCode_ : NameType = "hashCode" val hash_ : NameType = "hash" val head : NameType = "head" val immutable: NameType = "immutable" val implicitly: NameType = "implicitly" val in: NameType = "in" val internal: NameType = "internal" val inlinedEquals: NameType = "inlinedEquals" val isArray: NameType = "isArray" val isDefinedAt: NameType = "isDefinedAt" val isEmpty: NameType = "isEmpty" val isInstanceOf_ : NameType = "isInstanceOf" val isInstanceOf_Ob : NameType = "$isInstanceOf" val java: NameType = "java" val key: NameType = "key" val lang: NameType = "lang" val length: NameType = "length" val lengthCompare: NameType = "lengthCompare" val macroContext : NameType = "c" val main: NameType = "main" val manifestToTypeTag: NameType = "manifestToTypeTag" val map: NameType = "map" val materializeClassTag: NameType = "materializeClassTag" val materializeWeakTypeTag: NameType = "materializeWeakTypeTag" val materializeTypeTag: NameType = "materializeTypeTag" val moduleClass : NameType = "moduleClass" val mkAnnotation: NameType = "mkAnnotation" val mkEarlyDef: NameType = "mkEarlyDef" val mkIdent: NameType = "mkIdent" val mkPackageStat: NameType = "mkPackageStat" val mkRefineStat: NameType = "mkRefineStat" val mkRefTree: NameType = "mkRefTree" val mkSelect: NameType = "mkSelect" val mkThis: NameType = "mkThis" val mkTypeTree: NameType = "mkTypeTree" val ne: NameType = "ne" val newArray: NameType = "newArray" val newFreeTerm: NameType = "newFreeTerm" val newFreeType: NameType = "newFreeType" val newNestedSymbol: NameType = "newNestedSymbol" val newScopeWith: NameType = "newScopeWith" val notifyAll_ : NameType = "notifyAll" val notify_ : NameType = "notify" val null_ : NameType = "null" val pendingSuperCall: NameType = "pendingSuperCall" val prefix : NameType = "prefix" val productArity: NameType = "productArity" val productElement: NameType = "productElement" val productIterator: NameType = "productIterator" val productPrefix: NameType = "productPrefix" val readResolve: NameType = "readResolve" val reify : NameType = "reify" val reificationSupport : NameType = "reificationSupport" val rootMirror : NameType = "rootMirror" val runtime: NameType = "runtime" val runtimeClass: NameType = "runtimeClass" val runtimeMirror: NameType = "runtimeMirror" val scala_ : NameType = "scala" val selectDynamic: NameType = "selectDynamic" val selectOverloadedMethod: NameType = "selectOverloadedMethod" val selectTerm: NameType = "selectTerm" val selectType: NameType = "selectType" val self: NameType = "self" val setAnnotations: NameType = "setAnnotations" val setInfo: NameType = "setInfo" val setSymbol: NameType = "setSymbol" val setType: NameType = "setType" val splice: NameType = "splice" val staticClass : NameType = "staticClass" val staticModule : NameType = "staticModule" val staticPackage : NameType = "staticPackage" val synchronized_ : NameType = "synchronized" val ScalaDot: NameType = "ScalaDot" val TermName: NameType = "TermName" val this_ : NameType = "this" val thisPrefix : NameType = "thisPrefix" val toArray: NameType = "toArray" val toList: NameType = "toList" val toObjectArray : NameType = "toObjectArray" val toStats: NameType = "toStats" val TopScope: NameType = "TopScope" val toString_ : NameType = "toString" val toTypeConstructor: NameType = "toTypeConstructor" val tpe : NameType = "tpe" val tree : NameType = "tree" val true_ : NameType = "true" val typedProductIterator: NameType = "typedProductIterator" val TypeName: NameType = "TypeName" val typeTagToManifest: NameType = "typeTagToManifest" val unapply: NameType = "unapply" val unapplySeq: NameType = "unapplySeq" val unbox: NameType = "unbox" val universe: NameType = "universe" val UnliftListElementwise: NameType = "UnliftListElementwise" val UnliftListOfListsElementwise: NameType = "UnliftListOfListsElementwise" val update: NameType = "update" val updateDynamic: NameType = "updateDynamic" val value: NameType = "value" val valueOf : NameType = "valueOf" val values : NameType = "values" val wait_ : NameType = "wait" val withFilter: NameType = "withFilter" val zero: NameType = "zero" // quasiquote interpolators: val q: NameType = "q" val tq: NameType = "tq" val cq: NameType = "cq" val pq: NameType = "pq" val fq: NameType = "fq" // quasiquote's syntactic combinators val SyntacticAnnotatedType: NameType = "SyntacticAnnotatedType" val SyntacticApplied: NameType = "SyntacticApplied" val SyntacticAppliedType: NameType = "SyntacticAppliedType" val SyntacticAssign: NameType = "SyntacticAssign" val SyntacticBlock: NameType = "SyntacticBlock" val SyntacticClassDef: NameType = "SyntacticClassDef" val SyntacticCompoundType: NameType = "SyntacticCompoundType" val SyntacticDefDef: NameType = "SyntacticDefDef" val SyntacticEmptyTypeTree: NameType = "SyntacticEmptyTypeTree" val SyntacticExistentialType: NameType = "SyntacticExistentialType" val SyntacticFilter: NameType = "SyntacticFilter" val SyntacticFor: NameType = "SyntacticFor" val SyntacticForYield: NameType = "SyntacticForYield" val SyntacticFunction: NameType = "SyntacticFunction" val SyntacticFunctionType: NameType = "SyntacticFunctionType" val SyntacticImport: NameType = "SyntacticImport" val SyntacticMatch: NameType = "SyntacticMatch" val SyntacticNew: NameType = "SyntacticNew" val SyntacticObjectDef: NameType = "SyntacticObjectDef" val SyntacticPackageObjectDef: NameType = "SyntacticPackageObjectDef" val SyntacticPartialFunction: NameType = "SyntacticPartialFunction" val SyntacticPatDef: NameType = "SyntacticPatDef" val SyntacticSelectTerm: NameType = "SyntacticSelectTerm" val SyntacticSelectType: NameType = "SyntacticSelectType" val SyntacticSingletonType: NameType = "SyntacticSingletonType" val SyntacticTermIdent: NameType = "SyntacticTermIdent" val SyntacticTraitDef: NameType = "SyntacticTraitDef" val SyntacticTry: NameType = "SyntacticTry" val SyntacticTuple: NameType = "SyntacticTuple" val SyntacticTupleType: NameType = "SyntacticTupleType" val SyntacticTypeApplied: NameType = "SyntacticTypeApplied" val SyntacticTypeIdent: NameType = "SyntacticTypeIdent" val SyntacticTypeProjection: NameType = "SyntacticTypeProjection" val SyntacticValDef: NameType = "SyntacticValDef" val SyntacticValEq: NameType = "SyntacticValEq" val SyntacticValFrom: NameType = "SyntacticValFrom" val SyntacticVarDef: NameType = "SyntacticVarDef" // unencoded operators object raw { 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 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" // primitive operation methods for structual types mostly // overlap with the above, but not for these two. val toCharacter: NameType = "toCharacter" val toInteger: NameType = "toInteger" def newLazyValSlowComputeName(lzyValName: Name) = lzyValName append LAZY_SLOW_SUFFIX // ASCII names for operators val ADD = encode("+") val AND = encode("&") val ASR = encode(">>") val CONS = encode("::") val COLONPLUS = 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 MINGT = encode("->") val MOD = encode("%") val MUL = encode("*") val NE = encode("!=") val OR = encode("|") val PLUS = ADD // technically redundant, but ADD looks funny with MINUS val PLUSPLUS = encode("++") val SUB = MINUS // ... as does SUB with PLUS 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_!") // Grouped here so Cleanup knows what tests to perform. val CommonOpNames = Set[Name](OR, XOR, AND, EQ, NE) val BooleanOpNames = Set[Name](ZOR, ZAND, UNARY_!) ++ CommonOpNames val add: NameType = "add" val complement: NameType = "complement" val divide: NameType = "divide" val multiply: NameType = "multiply" val negate: NameType = "negate" val positive: NameType = "positive" val shiftLogicalRight: NameType = "shiftLogicalRight" val shiftSignedLeft: NameType = "shiftSignedLeft" val shiftSignedRight: NameType = "shiftSignedRight" val subtract: NameType = "subtract" val takeAnd: NameType = "takeAnd" val takeConditionalAnd: NameType = "takeConditionalAnd" val takeConditionalOr: NameType = "takeConditionalOr" val takeModulo: NameType = "takeModulo" val takeNot: NameType = "takeNot" val takeOr: NameType = "takeOr" val takeXor: NameType = "takeXor" val testEqual: NameType = "testEqual" val testGreaterOrEqualThan: NameType = "testGreaterOrEqualThan" val testGreaterThan: NameType = "testGreaterThan" val testLessOrEqualThan: NameType = "testLessOrEqualThan" val testLessThan: NameType = "testLessThan" val testNotEqual: NameType = "testNotEqual" def toUnaryName(name: TermName): TermName = name match { case raw.MINUS => UNARY_- case raw.PLUS => UNARY_+ case raw.TILDE => UNARY_~ case raw.BANG => UNARY_! case _ => name } /** The name of a method which stands in for a primitive operation * during structural type dispatch. */ def primitiveInfixMethodName(name: Name): TermName = name match { case OR => takeOr case XOR => takeXor case AND => takeAnd case EQ => testEqual case NE => testNotEqual case ADD => add case SUB => subtract case MUL => multiply case DIV => divide case MOD => takeModulo case LSL => shiftSignedLeft case LSR => shiftLogicalRight case ASR => shiftSignedRight case LT => testLessThan case LE => testLessOrEqualThan case GE => testGreaterOrEqualThan case GT => testGreaterThan case ZOR => takeConditionalOr case ZAND => takeConditionalAnd case _ => NO_NAME } /** Postfix/prefix, really. */ def primitivePostfixMethodName(name: Name): TermName = name match { case UNARY_! => takeNot case UNARY_+ => positive case UNARY_- => negate case UNARY_~ => complement case `toByte` => toByte case `toShort` => toShort case `toChar` => toCharacter case `toInt` => toInteger case `toLong` => toLong case `toFloat` => toFloat case `toDouble` => toDouble case _ => NO_NAME } def primitiveMethodName(name: Name): TermName = primitiveInfixMethodName(name) match { case NO_NAME => primitivePostfixMethodName(name) case name => 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) } } def newBitmapName(bitmapPrefix: Name, n: Int) = bitmapPrefix append ("" + n) val BITMAP_NORMAL: NameType = BITMAP_PREFIX + "" // initialization bitmap for public/protected lazy vals val BITMAP_TRANSIENT: NameType = BITMAP_PREFIX + "trans$" // initialization bitmap for transient lazy vals val BITMAP_CHECKINIT: NameType = BITMAP_PREFIX + "init$" // initialization bitmap for checkinit values val BITMAP_CHECKINIT_TRANSIENT: NameType = BITMAP_PREFIX + "inittrans$" // initialization bitmap for transient checkinit values } lazy val typeNames: tpnme.type = tpnme object tpnme extends TypeNames { } /** For fully qualified type names. */ object fulltpnme extends TypeNames { val RuntimeNothing: NameType = "scala.runtime.Nothing$" val RuntimeNull: NameType = "scala.runtime.Null$" } /** Java binary names, like scala/runtime/Nothing$. */ object binarynme { def toBinary(name: Name) = name mapName (_.replace('.', '/')) val RuntimeNothing = toBinary(fulltpnme.RuntimeNothing).toTypeName val RuntimeNull = toBinary(fulltpnme.RuntimeNull).toTypeName } val javanme = nme.javaKeywords lazy val termNames: nme.type = nme object nme extends TermNames { def moduleVarName(name: TermName): TermName = newTermNameCached("" + name + MODULE_VAR_SUFFIX) def getCause = sn.GetCause def getClass_ = sn.GetClass def getMethod_ = sn.GetMethod def invoke_ = sn.Invoke val isBoxedNumberOrBoolean: NameType = "isBoxedNumberOrBoolean" val isBoxedNumber: NameType = "isBoxedNumber" val reflPolyCacheName: NameType = "reflPoly$Cache" val reflParamsCacheName: NameType = "reflParams$Cache" val reflMethodName: NameType = "reflMethod$Method" } class JavaKeywords { private val kw = new KeywordSetBuilder 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 = kw.result } sealed abstract class SymbolNames { protected val stringToTermName = null protected val stringToTypeName = null protected implicit def createNameType(s: String): TypeName = newTypeNameCached(s) 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 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 Throwable: TypeName = "java.lang.Throwable" final val GetCause: TermName = newTermName("getCause") final val GetClass: TermName = newTermName("getClass") final val GetClassLoader: TermName = newTermName("getClassLoader") final val GetMethod: TermName = newTermName("getMethod") final val Invoke: TermName = newTermName("invoke") 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 ) } lazy val sn: SymbolNames = new SymbolNames { } } Other Scala source code examplesHere is a short list of links related to this Scala StdNames.scala source code file: |
... this post is sponsored by my books ... | |
#1 New Release! |
FP Best Seller |
Copyright 1998-2024 Alvin Alexander, alvinalexander.com
All Rights Reserved.
A percentage of advertising revenue from
pages under the /java/jwarehouse
URI on this website is
paid back to open source projects.