Packages

abstract class Namer extends Analyzer.MethodSynth with Analyzer.NamerContextErrors

Self Type
Analyzer.Namer
Source
Namers.scala
Type Hierarchy
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. Namer
  2. NamerContextErrors
  3. MethodSynth
  4. AnyRef
  5. Any
Implicitly
  1. by any2stringadd
  2. by StringFormat
  3. by Ensuring
  4. by ArrowAssoc
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. Protected

Instance Constructors

  1. new Namer(context: Analyzer.Context)

Value Members

  1. object NamerErrorGen
    Definition Classes
    NamerContextErrors
  2. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  3. final def ##: Int
    Definition Classes
    AnyRef → Any
  4. 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
  5. 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()
  6. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  7. def InferredImplicitError(tree: Global.Tree, inferred: Global.Type, cx: Analyzer.Context): Unit
    Definition Classes
    NamerContextErrors
  8. def accessorTypeCompleter(valDef: Global.ValDef, missingTpt: Boolean, isBean: Boolean, isSetter: Boolean): AccessorTypeCompleter
  9. 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:

    1. 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)

  10. def addCopyMethod(cdef: Global.ClassDef, namer: Analyzer.Namer): Unit
  11. def annotSig(annotations: List[Global.Tree], annotee: Global.Tree, pred: (Global.AnnotationInfo) => Boolean): List[Global.AnnotationInfo]
  12. def applicableTypeParams(owner: Global.Symbol): List[Global.Symbol]
  13. def applyUnapplyMethodCompleter(un_applyDef: Global.DefDef, companionContext: Analyzer.Context): Analyzer.TypeCompleter
  14. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  15. def assignAndEnterFinishedSymbol(tree: Global.MemberDef): Global.Symbol
  16. def assignMemberSymbol(tree: Global.MemberDef, mask: Long = -1L): Global.Symbol
  17. def clone(): AnyRef
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.CloneNotSupportedException]) @native()
  18. def completerOf(tree: Global.MemberDef): Analyzer.TypeCompleter
  19. def conflict(newS: Global.Symbol, oldS: Global.Symbol): Boolean
    Attributes
    protected
  20. val context: Analyzer.Context
  21. def contextFile: AbstractFile
  22. def copyMethodCompleter(copyDef: Global.DefDef): Analyzer.TypeCompleter
  23. def createImportSymbol(tree: Global.Import): Global.TermSymbol
  24. def createInnerNamer(): Analyzer.Namer
  25. 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.

  26. def createMethod(accessQual: Global.MemberDef, name: Global.TermName, pos: Global.Position, flags: Long): Global.MethodSymbol
  27. def createNamer(tree: Global.Tree): Analyzer.Namer
  28. def createPackageSymbol(pos: Global.Position, pid: Global.RefTree): Global.Symbol

    All PackageClassInfoTypes come from here.

  29. def createPrimaryConstructorParameterNamer: Analyzer.Namer
  30. def deriveAccessors(vd: Global.ValDef): Boolean
  31. def enclosingNamerWithScope(scope: Global.Scope): Analyzer.Namer
  32. 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 creator to class definition tree.

    If no companion object for clazz exists yet, create one by applying creator to class definition tree.

    returns

    the companion object symbol.

  33. 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
  34. 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
  35. 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
  36. 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
  37. def enterClassDef(tree: Global.ClassDef): Unit
  38. def enterClassSymbol(tree: Global.ClassDef): Global.Symbol
  39. def enterDefDef(tree: Global.DefDef): Unit
  40. 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

  41. def enterExistingSym(sym: Global.Symbol, tree: Global.Tree): Analyzer.Context
  42. def enterGetterSetter(tree: Global.ValDef): Unit
    Definition Classes
    MethodSynth
  43. def enterIfNotThere(sym: Global.Symbol): Unit
  44. def enterImplicitWrapper(classDef: Global.ClassDef): Unit
    Definition Classes
    MethodSynth
  45. def enterInScope(sym: Global.Symbol, scope: Global.Scope): sym.type

    Enter symbol into given scope and return symbol itself

  46. def enterInScope(sym: Global.Symbol): sym.type

    Enter symbol into context's scope and return symbol itself

  47. def enterModuleDef(tree: Global.ModuleDef): Unit
  48. def enterModuleSymbol(tree: Global.ModuleDef): Global.Symbol

    Enter a module symbol.

  49. def enterPackage(tree: Global.PackageDef): Unit
  50. def enterSelf(self: Global.ValDef): Unit
  51. def enterSym(tree: Global.Tree): Analyzer.Context
  52. def enterSyms(trees: List[Global.Tree]): Unit
  53. def enterSyntheticSym(tree: Global.Tree): Global.Symbol
  54. def enterTypeDef(tree: Global.TypeDef): Unit
  55. def enterValDef(tree: Global.ValDef): Unit
  56. def enterValueParams(vparamss: List[List[Global.ValDef]]): List[List[Global.Symbol]]
  57. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  58. def equals(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef → Any
  59. def expandMacroAnnotations(stats: List[Global.Tree]): List[Global.Tree]
  60. def finalize(): Unit
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.Throwable])
  61. def findCyclicalLowerBound(tp: Global.Type): Global.Symbol
    Annotations
    @nowarn()
  62. final def getClass(): Class[_ <: AnyRef]
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  63. def handleSyntheticNameConflict(sym1: Global.Symbol, sym2: Global.Symbol): Unit

    Logic to handle name conflicts of synthetically generated symbols We handle right now: t6227

  64. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  65. def implicitFactoryMethodCompleter(tree: Global.DefDef, classSym: Global.Symbol): Analyzer.CompleterWrapper
  66. def importTypeCompleter(tree: Global.Import): ImportTypeCompleter
  67. def inConstructorFlag: Long
  68. def includeParent(tpe: Global.Type, parent: Global.Symbol): Global.Type
  69. 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
  70. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  71. def moduleClassFlags(moduleFlags: Long): Long
  72. def moduleClassTypeCompleter(tree: Global.ModuleDef): ModuleClassTypeCompleter
  73. def monoTypeCompleter(tree: Global.MemberDef): MonoTypeCompleter
  74. def namerOf(sym: Global.Symbol): Analyzer.Namer
  75. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  76. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  77. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  78. def owner: Global.Symbol
    Attributes
    protected
  79. def saveDefaultGetter(meth: Global.Symbol, default: Global.Symbol): Unit
  80. def selfTypeCompleter(tree: Global.Tree): SelfTypeCompleter
  81. def setPrivateWithin(tree: Global.MemberDef, sym: Global.Symbol): sym.type
  82. def setPrivateWithin[T <: Global.Symbol](tree: Global.Tree, sym: T, mods: Global.Modifiers): sym.type
  83. 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)

  84. 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)

  85. final def synchronized[T0](arg0: => T0): T0
    Definition Classes
    AnyRef
  86. def toString(): String
    Definition Classes
    AnyRef → Any
  87. def typeErrorHandler[T](tree: Global.Tree, alt: T): PartialFunction[Throwable, T]
  88. 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).

  89. val typer: Analyzer.Typer
  90. def updatePosFlags(sym: Global.Symbol, pos: Global.Position, flags: Long): sym.type
  91. def valTypeCompleter(tree: Global.ValDef): ValTypeCompleter
  92. 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
    • abstract modifier only for classes
    • override modifier never for classes
    • def modifier never for parameters of case classes
    • declarations only in mixins or abstract classes (when not @native)
  93. 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.

  94. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  95. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  96. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException]) @native()

Deprecated Value Members

  1. 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
    @deprecated @inline()
    Deprecated

    (Since version 2.12.16) Use formatString.format(value) instead of value.formatted(formatString), or use the f"" string interpolator. In Java 15 and later, formatted resolves to the new method in String which has reversed parameters.

  2. 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.

Inherited from Analyzer.MethodSynth

Inherited from AnyRef

Inherited from Any

Inherited by implicit conversion any2stringadd fromAnalyzer.Namer to any2stringadd[Analyzer.Namer]

Inherited by implicit conversion StringFormat fromAnalyzer.Namer to StringFormat[Analyzer.Namer]

Inherited by implicit conversion Ensuring fromAnalyzer.Namer to Ensuring[Analyzer.Namer]

Inherited by implicit conversion ArrowAssoc fromAnalyzer.Namer to ArrowAssoc[Analyzer.Namer]

Ungrouped