SymbolTable

abstract val NoPosition: Position

abstract def currentRunId: RunId

The current compiler run identifier.

abstract def focusPos(pos: Position): Position

abstract def forInteractive: Boolean

abstract def forScaladoc: Boolean

abstract val gen: TreeGen { val global: SymbolTable.this.type }

abstract def isRangePos(pos: Position): Boolean

abstract def log(msg: ⇒ AnyRef): Unit

abstract def newLazyTreeCopier: TreeCopier

abstract def newStrictTreeCopier: TreeCopier

abstract val phaseWithId: Array[Phase]

The phase which has given index as identifier.

abstract def picklerPhase: Phase

abstract def settings: MutableSettings

abstract def showPos(pos: Position): String

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

object AnnotatedType extends AnnotatedTypeExtractor with Serializable

object AnnotationInfo extends AnnotationInfoExtractor

def Apply(sym: Symbol, args: Tree*): Tree

object ApproximateDependentMap extends TypeMap

object ArrayAnnotArg extends ArrayAnnotArgExtractor with Serializable

def Bind(sym: Symbol, body: Tree): Bind

def Block(stats: Tree*): Block

Block factory that flattens directly nested blocks.

final val BooleanTag: Int(2)

final val ByteTag: Int(3)

def CaseDef(pat: Tree, body: Tree): CaseDef

casedef shorthand

final val CharTag: Int(5)

def ClassDef(sym: Symbol, impl: Template): ClassDef

object ClassInfoType extends ClassInfoTypeExtractor with Serializable

final val ClassTag: Int(12)

object ConsoleWriter extends Writer

A writer that writes to the current Console and is sensitive to replacement of the Console's output stream.

object Constant extends ConstantExtractor with Serializable

object ConstantType extends ConstantTypeExtractor with Serializable

val CyclicInheritance: Throwable

def DefDef(sym: Symbol, rhs: (List[List[Symbol]]) ⇒ Tree): DefDef

def DefDef(sym: Symbol, rhs: Tree): DefDef

def DefDef(sym: Symbol, mods: Modifiers, rhs: Tree): DefDef

def DefDef(sym: Symbol, vparamss: List[List[ValDef]], rhs: Tree): DefDef

def DefDef(sym: Symbol, mods: Modifiers, vparamss: List[List[ValDef]], rhs: Tree): DefDef

final val DoubleTag: Int(9)

object EmptyScope extends Scope

The empty scope (immutable).

def EmptyTermName: TermName

lazy val EmptyTreeTypeSubstituter: TreeTypeSubstituter

def EmptyTypeName: TypeName

final val EnumTag: Int(13)

object ErroneousCollector extends TypeCollector[Boolean]

A map to implement the contains method.

object ErrorType extends Type with Product with Serializable

An object representing an erroneous type

object ExistentialType extends ExistentialTypeExtractor with Serializable

final val FloatTag: Int(8)

val GlbFailure: Throwable

object HasTypeMember extends AnyRef

object HasTypeParams extends AnyRef

def Ident(sym: Symbol): Ident

def Ident(name: String): Ident

final val IntTag: Int(6)

object IsDependentCollector extends TypeCollector[Boolean]

def JavaMethodType(params: List[Symbol], resultType: Type): JavaMethodType

The canonical creator for implicit method types

def LabelDef(sym: Symbol, params: List[Symbol], rhs: Tree): LabelDef

object LiteralAnnotArg extends LiteralAnnotArgExtractor with Serializable

final val LongTag: Int(7)

final val LubGlbMargin: Int(0)

object MethodType extends MethodTypeExtractor with Serializable

def Modifiers(mods: Set[Modifier], privateWithin: Name, annotations: List[Tree]): Modifiers

def Modifiers(flags: Long): Modifiers

def Modifiers(flags: Long, privateWithin: Name): Modifiers

def ModuleDef(sym: Symbol, impl: Template): ModuleDef

object NestedAnnotArg extends NestedAnnotArgExtractor with Serializable

def New(tpe: Type, args: Tree*): Tree

def New(sym: Symbol, args: Tree*): Tree

0-1 argument list new, based on a symbol or type.

def New(tpt: Tree, argss: List[List[Tree]]): Tree

val NoKindErrors: KindErrors

lazy val NoMods: Modifiers

final val NoPeriod: Int(0)

object NoPrefix extends Type with Product with Serializable

An object representing a non-existing prefix

final val NoRunId: Int(0)

lazy val NoSymbol: NoSymbol

final val NoTag: Int(0)

object NoType extends Type with Product with Serializable

An object representing a non-existing type

final val NullTag: Int(11)

object NullaryMethodType extends NullaryMethodTypeExtractor with Serializable

object PolyType extends PolyTypeExtractor with Serializable

object RefinedType extends RefinedTypeExtractor with Serializable

object Scope extends AnyRef

def Select(qualifier: Tree, sym: Symbol): Select

def Select(qualifier: Tree, name: String): Select

final val ShortTag: Int(4)

object SingleType extends SingleTypeExtractor with Serializable

final val StringTag: Int(10)

object StripAnnotationsMap extends TypeMap

def Super(sym: Symbol, mix: TypeName): Tree

object SuperType extends SuperTypeExtractor with Serializable

def This(sym: Symbol): Tree

object ThisType extends ThisTypeExtractor with Serializable

object TypeBounds extends TypeBoundsExtractor with Serializable

def TypeDef(sym: Symbol): TypeDef

A TypeDef node which defines abstract type or type parameter for given sym

def TypeDef(sym: Symbol, rhs: Tree): TypeDef

A TypeDef node which defines given sym with given tight hand side rhs.

object TypeRef extends TypeRefExtractor with Serializable

def TypeTree(tp: Type): TypeTree

object TypeVar extends AnyRef

final val UnitTag: Int(1)

object UnmappableAnnotation extends CompleteAnnotationInfo

object UnmappableTree extends Tree with TermTree with Product with Serializable

def ValDef(sym: Symbol): ValDef

def ValDef(sym: Symbol, rhs: Tree): ValDef

object WildcardType extends Type with Product with Serializable

An object representing an unknown type, used during type inference.

def abort(msg: String): Nothing

def abstractTypesToBounds(tp: Type): Type

Type with all top-level occurrences of abstract types replaced by their bounds

def adaptAnnotations(tree: Tree, mode: Int, pt: Type): Tree

Let registered annotation checkers adapt a tree to a given type (called by Typers.

def adaptBoundsToAnnotations(bounds: List[TypeBounds], tparams: List[Symbol], targs: List[Type]): List[TypeBounds]

Refine the bounds on type parameters to the given type arguments.

object adaptToNewRunMap extends TypeMap

def addAnnotationChecker(checker: AnnotationChecker): Unit

Register an annotation checker.

def addAnnotations(tree: Tree, tpe: Type): Type

Let all annotations checkers add extra annotations to this tree's type.

def addMember(thistp: Type, tp: Type, sym: Symbol): Unit

Make symbol sym a member of scope tp.decls where thistp is the narrowed owner type of the scope.

final def afterPhase[T](ph: Phase)(op: ⇒ T): T

def annotatedType(annots: List[AnnotationInfo], underlying: Type, selfsym: Symbol = NoSymbol): Type

Creator for AnnotatedTypes.

def annotationsConform(tp1: Type, tp2: Type): Boolean

Check that the annotations on two types conform.

def annotationsGlb(tpe: Type, ts: List[Type]): Type

Refine the computed greatest lower bound of a list of types.

def annotationsLub(tpe: Type, ts: List[Type]): Type

Refine the computed least upper bound of a list of types.

def appliedType(tycon: Type, args: List[Type]): Type

A creator for type applications

def appliedTypeAsUpperBounds(tycon: Type, args: List[Type]): Type

A creator for existential types where the type arguments, rather than being applied directly, are interpreted as the upper bounds of unknown types.

def arrayToRepeated(tp: Type): Type

Convert array parameters denoting a repeated parameter of a Java method to JavaRepeatedParamClass types.

final def asInstanceOf[T0]: T0

final def atPhase[T](ph: Phase)(op: ⇒ T): T

Perform given operation at given phase.

final def atPhaseNotLaterThan[T](target: Phase)(op: ⇒ T): T

def atPos[T <: Tree](pos: Position)(tree: T): T

def backquotedPath(t: Tree): String

Turns a path into a String, introducing backquotes as necessary.

def baseTypeOfNonClassTypeRef(tpe: NonClassTypeRef, clazz: Symbol): Type

def baseTypeSingletonSeq(tp: Type): BaseTypeSeq

Create a base type sequence consisting of a single type

final def beforePhase[T](ph: Phase)(op: ⇒ T): T

Since when it is to be "at" a phase is inherently ambiguous, a couple unambiguously named methods.

def beginsWithTypeVarOrIsRefined(tp: Type): Boolean

Does this type have a prefix that begins with a type variable, or is it a refinement type? For type prefixes that fulfil this condition, type selections with the same name of equal (wrt) =:= prefixes are considered equal wrt =:=

object binarynme extends AnyRef

Java binary names, like scala/runtime/Nothing$.

def canAdaptAnnotations(tree: Tree, mode: Int, pt: Type): Boolean

Find out whether any annotation checker can adapt a tree to a given type.

def checkKindBounds0(tparams: List[Symbol], targs: List[Type], pre: Type, owner: Symbol, explainErrors: Boolean): List[(Type, Symbol, KindErrors)]

Check well-kindedness of type application (assumes arities are already checked) -- @M

var chrs: Array[Char]

Memory to store all names sequentially.

val classCache: TwoWayCache[Class[_], Symbol]

def classToJava(clazz: Symbol): Class[_]

The Java class corresponding to given Scala class.

def classToScala(jclazz: Class[_]): Symbol

The Scala class that corresponds to a given Java class.

lazy val classfileAnnotArgManifest: ClassManifest[ClassfileAnnotArg]

def clone(): AnyRef

def cloneSymbols(syms: List[Symbol]): List[Symbol]

Convenience functions which derive symbols by cloning.

def cloneSymbolsAndModify(syms: List[Symbol], infoFn: (Type) ⇒ Type): List[Symbol]

Clone symbols and apply the given function to each new symbol's info.

def cloneSymbolsAtOwner(syms: List[Symbol], owner: Symbol): List[Symbol]

def cloneSymbolsAtOwnerAndModify(syms: List[Symbol], owner: Symbol, infoFn: (Type) ⇒ Type): List[Symbol]

final def collectMap2[A, B, C](xs1: List[A], xs2: List[B])(p: (A, B) ⇒ Boolean): Map[A, B]

def commonOwnerMap: CommonOwnerMap

final def compareLengths(xs1: List[_], xs2: List[_]): Int

def compoundBaseTypeSeq(tp: Type): BaseTypeSeq

Create the base type sequence of a compound type wuth given tp.

def connectModuleToClass(m: ModuleSymbol, moduleClass: ClassSymbol): ModuleSymbol

def constrToJava(constr: Symbol): java.lang.reflect.Constructor[_]

def constrToScala(jconstr: java.lang.reflect.Constructor[_]): Symbol

The Scala constructor corresponding to given Java constructor.

val constructorCache: TwoWayCache[java.lang.reflect.Constructor[_], Symbol]

def containsExistential(tpe: Type): Boolean

def copyMethodType(tp: Type, params: List[Symbol], restpe: Type): Type

Create a new MethodType of the same class as tp, i.

def copyRefinedType(original: RefinedType, parents: List[Type], decls: Scope): Type

def copyTypeRef(tp: Type, pre: Type, sym: Symbol, args: List[Type]): Type

final def corresponds3[A, B, C](xs1: List[A], xs2: List[B], xs3: List[C])(f: (A, B, C) ⇒ Boolean): Boolean

True if all three arguments have the same number of elements and the function is true for all the triples.

def createClassModule(owner: Symbol, name: TypeName, completer: (Symbol, Symbol) ⇒ LazyType): (ClassSymbol, ModuleSymbol)

Create a class and a companion object, enter in enclosing scope, and initialize with a lazy type completer.

def createFromClonedSymbols[T](syms: List[Symbol], tpe: Type)(creator: (List[Symbol], Type) ⇒ T): T

Functions which perform the standard clone/substituting on the given symbols and type, then call the creator function with the new symbols and type as arguments.

def createFromClonedSymbolsAtOwner[T](syms: List[Symbol], owner: Symbol, tpe: Type)(creator: (List[Symbol], Type) ⇒ T): T

final def currentPeriod: Period

The current period.

object deAlias extends TypeMap

Remove any occurrences of type aliases from this type

def debugInfo(msg: ⇒ String): Unit

def debugString(tp: Type): String

def debuglog(msg: ⇒ String): Unit

Override with final implementation for inlining.

def debugwarn(msg: ⇒ String): Unit

def decodedSymName(tree: Tree, name: Name): String

def defaultReflectiveClassLoader(): ClassLoader

def defineBaseClassesOfCompoundType(tpe: CompoundType): Unit

def defineBaseTypeSeqOfCompoundType(tpe: CompoundType): Unit

def defineBaseTypeSeqOfTypeRef(tpe: TypeRef): Unit

def defineParentsOfTypeRef(tpe: TypeRef): Unit

def defineUnderlyingOfSingleType(tpe: SingleType): Unit

object definitions extends AbsDefinitions with ValueClassDefinitions

def deriveFreshSkolems(tparams: List[Symbol]): List[Symbol]

Map a list of type parameter symbols to skolemized symbols, which can be deskolemized to the original type parameter.

def deriveSymbols(syms: List[Symbol], symFn: (Symbol) ⇒ Symbol): List[Symbol]

Derives a new list of symbols from the given list by mapping the given list across the given function.

def deriveType(syms: List[Symbol], symFn: (Symbol) ⇒ Symbol)(tpe: Type): Type

Derives a new Type by first deriving new symbols as in deriveSymbols, then performing the same oldSyms => newSyms substitution on tpe as is performed on the symbol infos in deriveSymbols.

def deriveTypeWithWildcards(syms: List[Symbol])(tpe: Type): Type

Derives a new Type by instantiating the given list of symbols as WildcardTypes.

def deskolemizeTypeParams(tparams: List[Symbol])(tp: Type): Type

Convert to corresponding type parameters all skolems of method parameters which appear in tparams.

def differentOrNone(tp1: Type, tp2: Type): Type

object dropAllRefinements extends TypeMap

Substitutes the empty scope for any non-empty decls in the type.

object dropRepeatedParamType extends TypeMap

object dropSingletonType extends TypeMap

Remove any occurrence of type <singleton> from this type and its parents

def duplicateTree(tree: Tree): Tree

def elimAnonymousClass(t: Type): Type

def elimRefinement(t: Type): Type

val emptySymbolArray: Array[Symbol]

object emptyValDef extends ValDef

val enableTypeVarExperimentals: Boolean

def encode(str: String): TermName

def ensureNonOverlapping(tree: Tree, others: List[Tree]): Unit

Ensure that given tree has no positions that overlap with any of the positions of others.

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def erasesTo(meth: Symbol, jconstr: java.lang.reflect.Constructor[_]): Boolean

Does constructor meth erase to Java method jconstr? This is true if the Java constructor type is the same as the Scala constructor type after performing all Scala-specific transformations in InfoTransformers.

def erasesTo(meth: Symbol, jmeth: Method): Boolean

Does method meth erase to Java method jmeth? This is true if the Java method type is the same as the Scala method type after performing all Scala-specific transformations in InfoTransformers.

def erasure: Erasure { val global: SymbolTable.this.type }

def etaExpandKeepsStar: Boolean

def existentialAbstraction(tparams: List[Symbol], tpe0: Type): Type

A creator for existential types.

def existentialsInType(tpe: Type): List[Symbol]

final def exists2[A, B](xs1: List[A], xs2: List[B])(f: (A, B) ⇒ Boolean): Boolean

def explain[T](op: String, p: (Type, T) ⇒ Boolean, tp1: Type, arg2: T): Boolean

Perform operation p on arguments tp1, arg2 and print trace of computation.

def explainTypes(op: (Type, Type) ⇒ Any, found: Type, required: Type): Unit

If option explaintypes is set, print a subtype trace for op(found, required).

def explainTypes(found: Type, required: Type): Unit

If option explaintypes is set, print a subtype trace for found <:< required.

val fieldCache: TwoWayCache[Field, Symbol]

def fieldToJava(fld: Symbol): Field

def finalize(): Unit

def findRecursiveBounds(ts: List[Type]): List[(Symbol, Symbol)]

From a list of types, find any which take type parameters where the type parameter bounds contain references to other any types in the list (including itself.

final def flatMap2[A, B, C](xs1: List[A], xs2: List[B])(f: (A, B) ⇒ List[C]): List[C]

def forMSIL: Boolean

Are we compiling for .

final def forall2[A, B](xs1: List[A], xs2: List[B])(f: (A, B) ⇒ Boolean): Boolean

final def forall3[A, B, C](xs1: List[A], xs2: List[B], xs3: List[C])(f: (A, B, C) ⇒ Boolean): Boolean

final def foreach2[A, B](xs1: List[A], xs2: List[B])(f: (A, B) ⇒ Unit): Unit

final def foreach3[A, B, C](xs1: List[A], xs2: List[B], xs3: List[C])(f: (A, B, C) ⇒ Unit): Unit

def freshExistentialName(suffix: String): TypeName

def fromDeBruijn(owner: Symbol): TypeMap

object fullnme extends TermNames

object fulltpnme extends TypeNames

For fully qualified type names.

def genericDeclarationToScala(jdecl: GenericDeclaration): Symbol

The Scala symbol that corresponds to a given Java generic declaration (class, method, or constructor)

final def getClass(): Class[_]

def glb(ts: List[Type]): Type

The greatest lower bound wrt <:< of a list of types

def glbNorm(ts: List[Type], depth: Int): Type

The greatest lower bound wrt <:< of a list of types, which have been normalized wrt elimSuper

final def hasLength(xs: List[_], len: Int): Boolean

Again avoiding calling length, but the lengthCompare interface is clunky.

def hashCode(): Int

var ids: Int

def inReflexiveMirror: Boolean

Is this symbol table part of reflexive mirror? In this case operations need to be made thread safe.

def info(msg: ⇒ String): Unit

var infoTransformers: InfoTransformer

The set of all installed infotransformers.

def initClassModule(clazz: Symbol, module: Symbol, completer: LazyType): Unit

def instTypeVar(tp: Type): Type

def instantiatedBounds(pre: Type, owner: Symbol, tparams: List[Symbol], targs: List[Type]): List[TypeBounds]

def intersectionType(tps: List[Type]): Type

A creator for intersection type where intersections of a single type are replaced by the type itself.

def intersectionType(tps: List[Type], owner: Symbol): Type

A creator for intersection type where intersections of a single type are replaced by the type itself, and repeated parent classes are merged.

val intersectionWitness: WeakHashMap[List[Type], WeakReference[Type]]

A map from lists to compound types that have the given list as parents.

def invalidClassName(name: Name): Boolean

Is the given name valid for a top-level class? We exclude names with embedded $-signs, because these are nested classes or anonymous classes,

def isConstantType(tp: Type): Boolean

def isDifferentType(tp1: Type, tp2: Type): Boolean

def isDifferentTypeConstructor(tp1: Type, tp2: Type): Boolean

def isErrorOrWildcard(tp: Type): Boolean

def isHKSubType0(tp1: Type, tp2: Type, depth: Int): Boolean

final def isInstanceOf[T0]: Boolean

def isJavaClass(path: String): Boolean

Does path correspond to a Java class with that fully qualified name?

def isNumericSubType(tp1: Type, tp2: Type): Boolean

The isNumericValueType tests appear redundant, but without them test/continuations-neg/function3.

def isPopulated(tp1: Type, tp2: Type): Boolean

Is intersection of given types populated? That is, for all types tp1, tp2 in intersection for all common base classes bc of tp1 and tp2 let bt1, bt2 be the base types of tp1, tp2 relative to class bc Then: bt1 and bt2 have the same prefix, and any corresponding non-variant type arguments of bt1 and bt2 are the same

def isRaw(sym: Symbol, args: List[Type]): Boolean

def isRawType(tp: Type): Boolean

Is type tp a raw type?

def isSameType(tp1: Type, tp2: Type): Boolean

Do tp1 and tp2 denote equivalent types?

def isSameType2(tp1: Type, tp2: Type): Boolean

def isSameTypes(tps1: List[Type], tps2: List[Type]): Boolean

Are tps1 and tps2 lists of pairwise equivalent types?

def isSingleType(tp: Type): Boolean

def isSubArg(t1: Type, t2: Type, variance: Int): Boolean

def isSubArgs(tps1: List[Type], tps2: List[Type], tparams: List[Symbol]): Boolean

def isSubType(tp1: Type, tp2: Type, depth: Int): Boolean

def isSubType(tp1: Type, tp2: Type): Boolean

def isSubTypes(tps1: List[Type], tps2: List[Type]): Boolean

Are tps1 and tps2 lists of equal length such that all elements of tps1 conform to corresponding elements of tps2?

final def isValid(period: Period): Boolean

final def isValidForBaseClasses(period: Period): Boolean

def isWeakSubType(tp1: Type, tp2: Type): Boolean

def isWithinBounds(pre: Type, owner: Symbol, tparams: List[Symbol], targs: List[Type]): Boolean

Do type arguments targs conform to formal parameters tparams?

def javaClass(path: String, classLoader: ClassLoader): Class[_]

def javaClass(path: String): Class[_]

Paul: It seems the default class loader does not pick up root classes, whereas the system classloader does.

val javanme: JavaKeywords

def kindsConform(tparams: List[Symbol], targs: List[Type], pre: Type, owner: Symbol): Boolean

implicit def lowerTermNames(n: TermName): String

def lub(ts: List[Type]): Type

def lubDepth(ts: List[Type]): Int

The maximum allowable depth of lubs or glbs over types ts.

def makeNoSymbol: NoSymbol with SynchronizedSymbol

def makeScalaPackage(fullname: String): Symbol

The Scala package with given fully qualified name.

final def map2[A, B, C](xs1: List[A], xs2: List[B])(f: (A, B) ⇒ C): List[C]

def map2Conserve[A <: AnyRef, B](xs: List[A], ys: List[B])(f: (A, B) ⇒ A): List[A]

like map2, but returns list xs itself - instead of a copy - if function f maps all elements to themselves.

final def map3[A, B, C, D](xs1: List[A], xs2: List[B], xs3: List[C])(f: (A, B, C) ⇒ D): List[D]

def mapParamss[T](sym: Symbol)(f: (Symbol) ⇒ T): List[List[T]]

A deep map on a symbol's paramss.

final def mapWithIndex[A, B](xs: List[A])(f: (A, Int) ⇒ B): List[B]

final def matchesType(tp1: Type, tp2: Type, alwaysMatchSimple: Boolean): Boolean

A function implementing tp1 matches tp2.

final val maxTostringRecursions: Int(50)

The maximum number of recursions allowed in toString

def mergePrefixAndArgs(tps: List[Type], variance: Int, depth: Int): Option[Type]

Compute lub (if variance == 1) or glb (if variance == -1) of given list of types tps.

val methodCache: TwoWayCache[Method, Symbol]

def methodToJava(meth: Symbol): Method

def methodToScala(jmeth: Method): Symbol

The Scala method corresponding to given Java method.

final def mexists[A](xss: List[List[A]])(p: (A) ⇒ Boolean): Boolean

All these mm methods are "deep map" style methods for mapping etc.

final def mfilter[A](xss: List[List[A]])(p: (A) ⇒ Boolean): List[A]

final def mfind[A](xss: List[List[A]])(p: (A) ⇒ Boolean): Option[A]

final def mforeach[A](xss: List[List[A]])(f: (A) ⇒ Unit): Unit

val missingAliasException: MissingAliasControl

def missingHook(owner: Symbol, name: Name): Symbol

If owner is a package class (but not the empty package) and name is a term name, make a new package <owner>.

final def mmap[A, B](xss: List[List[A]])(f: (A) ⇒ B): List[List[B]]

def nameChars: Array[Char]

final val nameDebug: Boolean(false)

final def ne(arg0: AnyRef): Boolean

def needsOuterTest(patType: Type, selType: Type, currentOwner: Symbol): Boolean

Does a pattern of type patType need an outer test when executed against selector type selType in context defined by currentOwner?

def newBaseTypeSeq(parents: List[Type], elems: Array[Type]): BaseTypeSeq with SynchronizedBaseTypeSeq

def newExistentialType(quantified: List[Symbol], underlying: Type): Type

A creator for existential types which flattens nested existentials.

def newFreeVar(name: TermName, tpe: Type, value: Any, newFlags: Long = 0L): FreeVar

Create a new free variable.

def newNestedScope(outer: Scope): Scope

Create a new scope nested in another one with which it shares its elements

def newPackageScope(pkgClass: Symbol): PackageScope

def newScope(): Scope with SynchronizedScope

Create a new scope

def newScopeWith(elems: Symbol*): Scope

Create a new scope with given initial elements

def newTermName(s: String): TermName

Create a term name from string.

def newTermName(bs: Array[Byte], offset: Int, len: Int): TermName

Create a term name from the UTF8 encoded bytes in bs[offset.

def newTermName(cs: Array[Char], offset: Int, len: Int, cachedString: String): TermName

Create a term name from the characters in cs[offset.

def newTermName(cs: Array[Char]): TermName

def newTermName(cs: Array[Char], offset: Int, len: Int): TermName