Packages

abstract class Namer extends Analyzer.MethodSynth with Analyzer.NamerContextErrors

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

Instance Constructors

  1. new Namer(context: Analyzer.Context)

Value Members

  1. object NamerErrorGen
    Definition Classes
    NamerContextErrors
  2. def accessorTypeCompleter(valDef: Global.ValDef, missingTpt: Boolean, isBean: Boolean, isSetter: Boolean): AccessorTypeCompleter
  3. 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)

  4. def addCopyMethod(cdef: Global.ClassDef, namer: Analyzer.Namer): Unit
  5. def annotSig(annotations: List[Global.Tree]): List[Global.AnnotationInfo]
  6. def applicableTypeParams(owner: Global.Symbol): List[Global.Symbol]
  7. def applyUnapplyMethodCompleter(un_applyDef: Global.DefDef, companionContext: Analyzer.Context): Analyzer.TypeCompleter
  8. def assignAndEnterFinishedSymbol(tree: Global.MemberDef): Global.Symbol
  9. def assignMemberSymbol(tree: Global.MemberDef, mask: Long = -1L): Global.Symbol
  10. def completerOf(tree: Global.MemberDef): Analyzer.TypeCompleter
  11. val context: Analyzer.Context
  12. def contextFile: AbstractFile
  13. def copyMethodCompleter(copyDef: Global.DefDef): Analyzer.TypeCompleter
  14. def createImportSymbol(tree: Global.Import): Global.TermSymbol
  15. def createInnerNamer(): Analyzer.Namer
  16. 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.

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

    All PackageClassInfoTypes come from here.

  20. def createPrimaryConstructorParameterNamer: Analyzer.Namer
  21. def deriveAccessors(vd: Global.ValDef): Boolean
  22. def enclosingNamerWithScope(scope: Global.Scope): Analyzer.Namer
  23. 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.

  24. def enterClassDef(tree: Global.ClassDef): Unit
  25. def enterClassSymbol(tree: Global.ClassDef): Global.Symbol
  26. def enterDefDef(tree: Global.DefDef): Unit
  27. def enterExistingSym(sym: Global.Symbol, tree: Global.Tree): Analyzer.Context
  28. def enterGetterSetter(tree: Global.ValDef): Unit
    Definition Classes
    MethodSynth
  29. def enterIfNotThere(sym: Global.Symbol): Unit
  30. def enterImplicitWrapper(classDef: Global.ClassDef): Unit
    Definition Classes
    MethodSynth
  31. def enterInScope(sym: Global.Symbol, scope: Global.Scope): Global.Symbol

    Enter symbol into given scope and return symbol itself

  32. def enterInScope(sym: Global.Symbol): Global.Symbol

    Enter symbol into context's scope and return symbol itself

  33. def enterModuleDef(tree: Global.ModuleDef): Global.Symbol
  34. def enterModuleSymbol(tree: Global.ModuleDef): Global.Symbol

    Enter a module symbol.

  35. def enterPackage(tree: Global.PackageDef): Unit
  36. def enterSelf(self: Global.ValDef): Unit
  37. def enterSym(tree: Global.Tree): Analyzer.Context
  38. def enterSyms(trees: List[Global.Tree]): Analyzer.Namer
  39. def enterSyntheticSym(tree: Global.Tree): Global.Symbol
  40. def enterTypeDef(tree: Global.TypeDef): Global.Symbol
  41. def enterValDef(tree: Global.ValDef): Unit
  42. def enterValueParams(vparamss: List[List[Global.ValDef]]): List[List[Global.Symbol]]
  43. def findCyclicalLowerBound(tp: Global.Type): Global.Symbol
  44. def handleSyntheticNameConflict(sym1: Global.Symbol, sym2: Global.Symbol): Unit

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

  45. def implicitFactoryMethodCompleter(tree: Global.DefDef, classSym: Global.Symbol): Analyzer.CompleterWrapper
  46. def importTypeCompleter(tree: Global.Import): ImportTypeCompleter
  47. def inConstructorFlag: Long
  48. def includeParent(tpe: Global.Type, parent: Global.Symbol): Global.Type
  49. 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
  50. def moduleClassFlags(moduleFlags: Long): Long
  51. def moduleClassTypeCompleter(tree: Global.ModuleDef): ModuleClassTypeCompleter
  52. def monoTypeCompleter(tree: Global.MemberDef): MonoTypeCompleter
  53. def namerOf(sym: Global.Symbol): Analyzer.Namer
  54. def saveDefaultGetter(meth: Global.Symbol, default: Global.Symbol): Unit
  55. def selfTypeCompleter(tree: Global.Tree): SelfTypeCompleter
  56. def setPrivateWithin(tree: Global.MemberDef, sym: Global.Symbol): Global.Symbol
  57. def setPrivateWithin[T <: Global.Symbol](tree: Global.Tree, sym: T, mods: Global.Modifiers): T
  58. 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)

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

  60. def typeErrorHandler[T](tree: Global.Tree, alt: T): PartialFunction[Throwable, T]
  61. 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).

  62. val typer: Analyzer.Typer
  63. def updatePosFlags(sym: Global.Symbol, pos: Global.Position, flags: Long): Global.Symbol
  64. def valTypeCompleter(tree: Global.ValDef): ValTypeCompleter
  65. 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)
  66. 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.