abstract class Namer extends Analyzer.MethodSynth with Analyzer.NamerContextErrors
Ordering
- Alphabetic
- By Inheritance
Inherited
- Namer
- NamerContextErrors
- MethodSynth
- AnyRef
- Any
Implicitly
- by any2stringadd
- by StringFormat
- by Ensuring
- by ArrowAssoc
- Hide All
- Show All
Visibility
- Public
- Protected
Instance Constructors
- new Namer(context: Analyzer.Context)
Type Members
- trait DerivedAccessor extends AnyRef
- Definition Classes
- MethodSynth
- case class Getter(tree: Global.ValDef) extends Namers.Namer.DerivedAccessor with Product with Serializable
- Definition Classes
- MethodSynth
- case class Setter(tree: Global.ValDef) extends Namers.Namer.DerivedAccessor with Product with Serializable
- Definition Classes
- MethodSynth
- class AccessorTypeCompleter extends Analyzer.TypeCompleterBase[Global.ValDef]
- class ImportTypeCompleter extends Analyzer.TypeCompleterBase[Global.Import]
- class ModuleClassTypeCompleter extends Analyzer.TypeCompleterBase[Global.ModuleDef]
- class MonoTypeCompleter extends Analyzer.TypeCompleterBase[Global.MemberDef]
- class SelfTypeCompleter extends Analyzer.TypeCompleterBase[Global.Tree]
- class ValTypeCompleter extends Analyzer.TypeCompleterBase[Global.ValDef]
Value Members
- object NamerErrorGen
- Definition Classes
- NamerContextErrors
- final def !=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- final def ##(): Int
- Definition Classes
- AnyRef → Any
- def +(other: String): String
- Implicit
- This member is added by an implicit conversion from Analyzer.Namer toany2stringadd[Analyzer.Namer] performed by method any2stringadd in scala.Predef.
- Definition Classes
- any2stringadd
- def ->[B](y: B): (Analyzer.Namer, B)
- Implicit
- This member is added by an implicit conversion from Analyzer.Namer toArrowAssoc[Analyzer.Namer] performed by method ArrowAssoc in scala.Predef.
- Definition Classes
- ArrowAssoc
- Annotations
- @inline()
- final def ==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- def accessorTypeCompleter(valDef: Global.ValDef, missingTpt: Boolean, isBean: Boolean, isSetter: Boolean): AccessorTypeCompleter
- def addApplyUnapply(cdef: Global.ClassDef, namer: Analyzer.Namer): Unit
Given a case class case class C[Ts] (ps: Us) Add the following methods to toScope:
Given a case class case class C[Ts] (ps: Us) Add the following methods to toScope:
- if case class is not abstract, add <synthetic> <case> def apply[Ts](ps: Us): C[Ts] = new C[Ts](ps) 2. add a method <synthetic> <case> def unapply[Ts](x: C[Ts]) = <ret-val> where <ret-val> is the caseClassUnapplyReturnValue of class C (see UnApplies.scala)
- cdef
is the class definition of the case class
- namer
is the namer of the module class (the comp. obj)
- def addCopyMethod(cdef: Global.ClassDef, namer: Analyzer.Namer): Unit
- def annotSig(annotations: List[Global.Tree], pred: (Global.AnnotationInfo) => Boolean): List[Global.AnnotationInfo]
- def applicableTypeParams(owner: Global.Symbol): List[Global.Symbol]
- def applyUnapplyMethodCompleter(un_applyDef: Global.DefDef, companionContext: Analyzer.Context): Analyzer.TypeCompleter
- final def asInstanceOf[T0]: T0
- Definition Classes
- Any
- def assignAndEnterFinishedSymbol(tree: Global.MemberDef): Global.Symbol
- def assignMemberSymbol(tree: Global.MemberDef, mask: Long = -1L): Global.Symbol
- def clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.CloneNotSupportedException]) @native()
- def completerOf(tree: Global.MemberDef): Analyzer.TypeCompleter
- def conflict(newS: Global.Symbol, oldS: Global.Symbol): Boolean
- Attributes
- protected
- val context: Analyzer.Context
- def contextFile: AbstractFile
- def copyMethodCompleter(copyDef: Global.DefDef): Analyzer.TypeCompleter
- def createImportSymbol(tree: Global.Import): Global.TermSymbol
- def createInnerNamer(): Analyzer.Namer
- def createMemberSymbol(tree: Global.MemberDef, name: Global.Name, mask: Long): Global.Symbol
Create a new symbol at the context owner based on the given tree.
Create a new symbol at the context owner based on the given tree. A different name can be given. If the modifier flags should not be be transferred to the symbol as they are, supply a mask containing the flags to keep.
- def createMethod(accessQual: Global.MemberDef, name: Global.TermName, pos: Global.Position, flags: Long): Global.MethodSymbol
- def createNamer(tree: Global.Tree): Analyzer.Namer
- def createPackageSymbol(pos: Global.Position, pid: Global.RefTree): Global.Symbol
All PackageClassInfoTypes come from here.
- def createPrimaryConstructorParameterNamer: Analyzer.Namer
- def deriveAccessors(vd: Global.ValDef): Boolean
- def enclosingNamerWithScope(scope: Global.Scope): Analyzer.Namer
- def ensureCompanionObject(cdef: Global.ClassDef, creator: (Global.ClassDef) => Global.Tree = companionModuleDef(_)): Global.Symbol
If no companion object for clazz exists yet, create one by applying
creatorto class definition tree.If no companion object for clazz exists yet, create one by applying
creatorto class definition tree.- returns
the companion object symbol.
- def ensuring(cond: (Analyzer.Namer) => Boolean, msg: => Any): Analyzer.Namer
- Implicit
- This member is added by an implicit conversion from Analyzer.Namer toEnsuring[Analyzer.Namer] performed by method Ensuring in scala.Predef.
- Definition Classes
- Ensuring
- def ensuring(cond: (Analyzer.Namer) => Boolean): Analyzer.Namer
- Implicit
- This member is added by an implicit conversion from Analyzer.Namer toEnsuring[Analyzer.Namer] performed by method Ensuring in scala.Predef.
- Definition Classes
- Ensuring
- def ensuring(cond: Boolean, msg: => Any): Analyzer.Namer
- Implicit
- This member is added by an implicit conversion from Analyzer.Namer toEnsuring[Analyzer.Namer] performed by method Ensuring in scala.Predef.
- Definition Classes
- Ensuring
- def ensuring(cond: Boolean): Analyzer.Namer
- Implicit
- This member is added by an implicit conversion from Analyzer.Namer toEnsuring[Analyzer.Namer] performed by method Ensuring in scala.Predef.
- Definition Classes
- Ensuring
- def enterClassDef(tree: Global.ClassDef): Unit
- def enterClassSymbol(tree: Global.ClassDef): Global.Symbol
- def enterDefDef(tree: Global.DefDef): Unit
- def enterDefaultGetters(meth: Global.Symbol, ddef: Global.DefDef, vparamss: List[List[Global.ValDef]], tparams: List[Global.TypeDef]): Unit
For every default argument, insert a method symbol computing that default
- def enterExistingSym(sym: Global.Symbol, tree: Global.Tree): Analyzer.Context
- def enterGetterSetter(tree: Global.ValDef): Unit
- Definition Classes
- MethodSynth
- def enterIfNotThere(sym: Global.Symbol): Unit
- def enterImplicitWrapper(classDef: Global.ClassDef): Unit
- Definition Classes
- MethodSynth
- def enterInScope(sym: Global.Symbol, scope: Global.Scope): Global.Symbol
Enter symbol into given scope and return symbol itself
- def enterInScope(sym: Global.Symbol): Global.Symbol
Enter symbol into context's scope and return symbol itself
- def enterModuleDef(tree: Global.ModuleDef): Global.Symbol
- def enterModuleSymbol(tree: Global.ModuleDef): Global.Symbol
Enter a module symbol.
- def enterPackage(tree: Global.PackageDef): Unit
- def enterSelf(self: Global.ValDef): Unit
- def enterSym(tree: Global.Tree): Analyzer.Context
- def enterSyms(trees: List[Global.Tree]): Analyzer.Namer
- def enterSyntheticSym(tree: Global.Tree): Global.Symbol
- def enterTypeDef(tree: Global.TypeDef): Global.Symbol
- def enterValDef(tree: Global.ValDef): Unit
- def enterValueParams(vparamss: List[List[Global.ValDef]]): List[List[Global.Symbol]]
- final def eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def equals(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef → Any
- def expandMacroAnnotations(stats: List[Global.Tree]): List[Global.Tree]
- def finalize(): Unit
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.Throwable])
- def findCyclicalLowerBound(tp: Global.Type): Global.Symbol
- def formatted(fmtstr: String): String
- Implicit
- This member is added by an implicit conversion from Analyzer.Namer toStringFormat[Analyzer.Namer] performed by method StringFormat in scala.Predef.
- Definition Classes
- StringFormat
- Annotations
- @inline()
- final def getClass(): Class[_ <: AnyRef]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- def handleSyntheticNameConflict(sym1: Global.Symbol, sym2: Global.Symbol): Unit
Logic to handle name conflicts of synthetically generated symbols We handle right now: t6227
- def hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- def implicitFactoryMethodCompleter(tree: Global.DefDef, classSym: Global.Symbol): Analyzer.CompleterWrapper
- def importTypeCompleter(tree: Global.Import): ImportTypeCompleter
- def inConstructorFlag: Long
- def includeParent(tpe: Global.Type, parent: Global.Symbol): Global.Type
- def isEnumConstant(vd: Global.ValDef): Boolean
Determines whether this field holds an enum constant.
Determines whether this field holds an enum constant. To qualify, the following conditions must be met:
- The field's class has the ENUM flag set
- The field's class extends java.lang.Enum
- The field has the ENUM flag set
- The field is static
- The field is stable
- final def isInstanceOf[T0]: Boolean
- Definition Classes
- Any
- def moduleClassFlags(moduleFlags: Long): Long
- def moduleClassTypeCompleter(tree: Global.ModuleDef): ModuleClassTypeCompleter
- def monoTypeCompleter(tree: Global.MemberDef): MonoTypeCompleter
- def namerOf(sym: Global.Symbol): Analyzer.Namer
- final def ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- final def notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- final def notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- def owner: Global.Symbol
- Attributes
- protected
- def saveDefaultGetter(meth: Global.Symbol, default: Global.Symbol): Unit
- def selfTypeCompleter(tree: Global.Tree): SelfTypeCompleter
- def setPrivateWithin(tree: Global.MemberDef, sym: Global.Symbol): Global.Symbol
- def setPrivateWithin[T <: Global.Symbol](tree: Global.Tree, sym: T, mods: Global.Modifiers): T
- def standardEnsureCompanionObject(cdef: Global.ClassDef, creator: (Global.ClassDef) => Global.Tree = companionModuleDef(_)): Global.Symbol
Default implementation of
ensureCompanionObject.Default implementation of
ensureCompanionObject. Can be overridden by analyzer plugins (see AnalyzerPlugins.pluginsEnsureCompanionObject for more details) - def standardEnterSym(tree: Global.Tree): Analyzer.Context
Default implementation of
enterSym.Default implementation of
enterSym. Can be overridden by analyzer plugins (see AnalyzerPlugins.pluginsEnterSym for more details) - final def synchronized[T0](arg0: => T0): T0
- Definition Classes
- AnyRef
- def toString(): String
- Definition Classes
- AnyRef → Any
- def typeErrorHandler[T](tree: Global.Tree, alt: T): PartialFunction[Throwable, T]
- def typeSig(tree: Global.Tree, annotSigs: List[Global.AnnotationInfo]): Global.Type
TypeSig is invoked by monoTypeCompleters.
TypeSig is invoked by monoTypeCompleters. It returns the type of a definition which is then assigned to the corresponding symbol (typeSig itself does not need to assign the type to the symbol, but it can if necessary).
- val typer: Analyzer.Typer
- def updatePosFlags(sym: Global.Symbol, pos: Global.Position, flags: Long): Global.Symbol
- def valTypeCompleter(tree: Global.ValDef): ValTypeCompleter
- def validate(sym: Global.Symbol): Unit
Check that symbol's definition is well-formed.
Check that symbol's definition is well-formed. This means:
- no conflicting modifiers
abstractmodifier only for classesoverridemodifier never for classesdefmodifier never for parameters of case classes- declarations only in mixins or abstract classes (when not @native)
- def validateCompanionDefs(tree: Global.ImplDef): Unit
Given a ClassDef or ModuleDef, verifies there isn't a companion which has been defined in a separate file.
- final def wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException]) @native()
Deprecated Value Members
- def →[B](y: B): (Analyzer.Namer, B)
- Implicit
- This member is added by an implicit conversion from Analyzer.Namer toArrowAssoc[Analyzer.Namer] performed by method ArrowAssoc in scala.Predef.
- Definition Classes
- ArrowAssoc
- Annotations
- @deprecated
- Deprecated
(Since version 2.13.0) Use
->instead. If you still wish to display it as one character, consider using a font with programming ligatures such as Fira Code.
The Scala compiler and reflection APIs.