scala.tools.nsc.Global

# erasure

###
Related Doc: package Global

#### object erasure extends Erasure

Definition Classes
  Global → Transforms
Source
  Global.scala

Linear Supertypes
Erasure, TypeAdaptingTransformer, TypingTransformers, Analyzer, AnalyzerPlugins, StdAttachments, ContextErrors, TypeDiagnostics, NamesDefaults, Macros, Helpers, Traces, MacroRuntimes, JavaReflectionRuntimes, Unapplies, SyntheticMethods, TreeDSL, EtaExpansion, Implicits, Infer, Checkable, Typers, PatternTypers, TypersTracking, Tags, Adaptations, Namers, MethodSynthesis, Contexts, Erasure, AddInterfaces, InfoTransform, Transform, SubComponent, AnyRef, Any
Content Hierarchy Learn more about scaladoc diagrams
Ordering

1. Alphabetic
2. By inheritance

Inherited

1. erasure
2. Erasure
3. TypeAdaptingTransformer
4. TypingTransformers
5. Analyzer
6. AnalyzerPlugins
7. StdAttachments
8. ContextErrors
9. TypeDiagnostics
10. NamesDefaults
11. Macros
12. Helpers
13. Traces
14. MacroRuntimes
15. JavaReflectionRuntimes
16. Unapplies
17. SyntheticMethods
18. TreeDSL
19. EtaExpansion
20. Implicits
21. Infer
22. Checkable
23. Typers
24. PatternTypers
25. TypersTracking
26. Tags
27. Adaptations
28. Namers
29. MethodSynthesis
30. Contexts
31. Erasure
32. AddInterfaces
33. InfoTransform
34. Transform
35. SubComponent
36. AnyRef
37. Any

1. Hide All
2. Show all

Learn more about member selection
Visibility

1. Public
2. All

### Type Members

1. #### abstract class AbsAmbiguousTypeError extends Analyzer.AbsTypeError

   Definition Classes
     ContextErrors

2. #### sealed abstract class AbsTypeError extends Throwable

   Definition Classes
     ContextErrors

3. #### case class AccessTypeError(underlyingTree: Global.Tree, errMsg: String) extends Analyzer.TreeTypeError with Product with Serializable

   Definition Classes
     ContextErrors

4. #### trait Adaptation extends AnyRef

   Definition Classes
     Adaptations

5. #### case class AmbiguousImplicitTypeError(underlyingTree: Global.Tree, errMsg: String) extends Analyzer.AbsAmbiguousTypeError with Product with Serializable

   Definition Classes
     ContextErrors

6. #### case class AmbiguousTypeError(errPos: Global.Position, errMsg: String) extends Analyzer.AbsAmbiguousTypeError with Product with Serializable

   Definition Classes
     ContextErrors

7. #### trait AnalyzerPlugin extends AnyRef

   Definition Classes
     AnalyzerPlugins

8. #### class ClassForCaseCompanionAttachment extends AnyRef

   Definition Classes
     Unapplies

9. #### class ClassMethodSynthesis extends AnyRef

   Definition Classes
     MethodSynthesis

10. #### class ComputeBridges extends AnyRef

    Definition Classes
      Erasure

11. #### class ConstructorDefaultsAttachment extends AnyRef

    Definition Classes
      NamesDefaults

12. #### class Context extends AnyRef

    A motley collection of the state and loosely associated behaviour of the type checker.

    A motley collection of the state and loosely associated behaviour of the type checker. Each `Typer` has an associated context, and as it descends into the tree new `(Typer, Context)` pairs are spawned.

    Meet the crew; first the state:

    - A tree, symbol, and scope representing the focus of the typechecker
    - An enclosing context, `outer`.
    - The current compilation unit.
    - A variety of bits that track the current error reporting policy (more on this later); whether or not implicits/macros are enabled, whether we are in a self or super call or in a constructor suffix. These are represented as bits in the mask `contextMode`.
    - Some odds and ends: undetermined type parameters of the current line of type inference; contextual augmentation for error messages, tracking of the nesting depth.

    And behaviour:

    - The central point for issuing errors and warnings from the typechecker, with a means to buffer these for use in 'silent' type checking, when some recovery might be possible.
    - `Context` is something of a Zipper for the tree were are typechecking: it `enclosingContextChain` is the path back to the root. This is exactly what we need to resolve names (`lookupSymbol`) and to collect in-scope implicit definitions (`implicitss`) Supporting these are `imports`, which represents all `Import` trees in in the enclosing context chain.
    - In a similar vein, we can assess accessibility (`isAccessible`.)

    More on error buffering: When are type errors recoverable? In quite a few places, it turns out. Some examples: trying to type an application with/without the expected type, or with/without implicit views enabled. This is usually mediated by `Typer.silent`, `Inferencer#tryTwice`.

    Initially, starting from the `typer` phase, the contexts either buffer or report errors; afterwards errors are thrown. This is configured in `rootContext`. Additionally, more fine grained control is needed based on the kind of error; ambiguity errors are often suppressed during exploratory typing, such as determining whether `a == b` in an argument position is an assignment or a named argument, when `Infererencer#isApplicableSafe` type checks applications with and without an expected type, or whtn `Typer#tryTypedApply` tries to fit arguments to a function type with/without implicit views.

    When the error policies entails error/warning buffering, the mutable ReportBuffer records everything that is issued. It is important to note, that child Contexts created with `make` "inherit" the very same `ReportBuffer` instance, whereas children spawned through `makeSilent` receive an separate, fresh buffer.

    Definition Classes
      Contexts

13. #### abstract class ContextReporter extends Reporter

    A reporter for use during type checking.

    A reporter for use during type checking. It has multiple modes for handling errors.

    The default (immediate mode) is to send the error to the global reporter. When switched into buffering mode via makeBuffering, errors and warnings are buffered and not be reported (there's a special case for ambiguity errors for some reason: those are force to the reporter when context.ambiguousErrors, or else they are buffered -- TODO: can we simplify this?)

    When using the type checker after typers, an error results in a TypeError being thrown. TODO: get rid of this mode.

    To handle nested contexts, reporters share buffers. TODO: only buffer in BufferingReporter, emit immediately in ImmediateReporter

    Definition Classes
      Contexts

14. #### class DefMacroExpander extends Analyzer.MacroExpander

    Expands a term macro used in apply role as `M(2)(3)` in `val x = M(2)(3)`.

    Expands a term macro used in apply role as `M(2)(3)` in `val x = M(2)(3)`.

    Definition Classes
      Macros

15. #### class DefaultsOfLocalMethodAttachment extends AnyRef

    Definition Classes
      NamesDefaults

16. #### case class Delayed(delayed: Global.Tree) extends Analyzer.MacroStatus with Product with Serializable

    Definition Classes
      Macros

17. #### case class DivergentImplicitTypeError(underlyingTree: Global.Tree, pt0: Global.Type, sym: Global.Symbol) extends Analyzer.TreeTypeError with Product with Serializable

    Definition Classes
      ContextErrors

18. #### class Eraser extends Typer with TypeAdapter

    The modifier typer which retypes with erased types.

    The modifier typer which retypes with erased types.

    Definition Classes
      Erasure

19. #### abstract class ErasureMap extends reflect.internal.SymbolTable.TypeMap

    Definition Classes
      Erasure

20. #### class ErasureTransformer extends Global.Transformer

    The erasure transformer

    The erasure transformer

    Definition Classes
      Erasure

21. #### case class Failure(failure: Global.Tree) extends Analyzer.MacroStatus with Product with Serializable

    Definition Classes
      Macros

22. #### case class Fallback(fallback: Global.Tree) extends Analyzer.MacroStatus with Product with Serializable

    Definition Classes
      Macros

23. #### class ImplicitInfo extends AnyRef

    A class that records an available implicit

    A class that records an available implicit

    Definition Classes
      Implicits

24. #### class ImplicitSearch extends Analyzer.Typer with Analyzer.ImplicitsContextErrors

    A class that sets up an implicit search.

    A class that sets up an implicit search. For more info, see comments for `inferImplicit`.

    Definition Classes
      Implicits

25. #### trait ImplicitsContextErrors extends AnyRef

    Definition Classes
      ContextErrors

26. #### trait ImportContext extends Analyzer.Context

    A `Context` focussed on an `Import` tree

    A `Context` focussed on an `Import` tree

    Definition Classes
      Contexts

27. #### class ImportInfo extends AnyRef

    Definition Classes
      Contexts

28. #### type ImportType = Global.ImportType

    Definition Classes
      Contexts

29. #### trait InferCheckable extends AnyRef

    Definition Classes
      Checkable

30. #### abstract class Inferencer extends Analyzer.InferencerContextErrors with Analyzer.InferCheckable

    The context-dependent inferencer part

    The context-dependent inferencer part

    Definition Classes
      Infer

31. #### trait InferencerContextErrors extends AnyRef

    Definition Classes
      ContextErrors

32. #### class JavaErasureMap extends ErasureMap

    Definition Classes
      Erasure

33. #### trait JavaReflectionResolvers extends AnyRef

    Definition Classes
      JavaReflectionRuntimes

34. #### trait LockingTypeCompleter extends Analyzer.TypeCompleter

    Definition Classes
      Namers

35. #### case class MacroArgs(c: Analyzer.MacroContext, others: List[Any]) extends Product with Serializable

    Calculate the arguments to pass to a macro implementation when expanding the provided tree.

    Calculate the arguments to pass to a macro implementation when expanding the provided tree.

    Definition Classes
      Macros

36. #### type MacroContext = UnaffiliatedMacroContext { val universe: scala.tools.nsc.Global.erasure.global.type }

    Definition Classes
      StdAttachments

37. #### abstract class MacroExpander extends AnyRef

    Performs macro expansion:

    Performs macro expansion:

    ###### Expandable trees

    A term of one of the following shapes:

    Ident(<term macro>) Select(<any qualifier>, <term macro>) TypeApply(<any of the above>, <targs>) Apply(...Apply(<any of the above>, <args1>)...<argsN>)

    ###### Macro expansion

    First of all `macroExpandXXX`: 1) If necessary desugars the `expandee` to fit into the default expansion scheme that is understood by `macroExpandWithRuntime` / `macroExpandWithoutRuntime`

    Then `macroExpandWithRuntime`: 2) Checks whether the expansion needs to be delayed 3) Loads macro implementation using `macroMirror` 4) Synthesizes invocation arguments for the macro implementation 5) Checks that the result is a tree or an expr bound to this universe

    Finally `macroExpandXXX`: 6) Validates the expansion against the white list of supported tree shapes 7) Typechecks the result as required by the circumstances of the macro application

    If -Ymacro-debug-lite is enabled, you will get basic notifications about macro expansion along with macro expansions logged in the form that can be copy/pasted verbatim into REPL.

    If -Ymacro-debug-verbose is enabled, you will get detailed log of how exactly this function performs class loading and method resolution in order to load the macro implementation. The log will also include other non-trivial steps of macro expansion.

    returns

      the expansion result if the expansion has been successful, the fallback tree if the expansion has been unsuccessful, but there is a fallback, the expandee unchanged if the expansion has been delayed, the expandee fully expanded if the expansion has been delayed before and has been expanded now, the expandee with an error marker set if the expansion has been cancelled due malformed arguments or implementation the expandee with an error marker set if there has been an error

    Definition Classes
      Macros

38. #### case class MacroExpanderAttachment(original: Global.Tree, desugared: Global.Tree) extends Product with Serializable

    Scratchpad for the macro expander, which is used to store all intermediate data except the details about the runtime.

    Scratchpad for the macro expander, which is used to store all intermediate data except the details about the runtime.

    Definition Classes
      StdAttachments

39. #### case class MacroExpansionAttachment(expandee: Global.Tree, expanded: Any) extends Product with Serializable

    Is added by the macro engine to originals and results of macro expansions.

    Is added by the macro engine to originals and results of macro expansions. Stores the original expandee as it entered the `macroExpand` function.

    Definition Classes
      StdAttachments

40. #### case class MacroImplBinding(isBundle: Boolean, isBlackbox: Boolean, className: String, methName: String, signature: List[List[Fingerprint]], targs: List[Global.Tree]) extends Product with Serializable

    Represents all the information that a macro definition needs to know about its implementation.

    Represents all the information that a macro definition needs to know about its implementation. Includes a path to load the implementation via Java reflection, and various accounting information necessary when composing an argument list for the reflective invocation.

    Definition Classes
      Macros

41. #### trait MacroPlugin extends AnyRef

    Definition Classes
      AnalyzerPlugins

42. #### type MacroRuntime = (MacroArgs) ⇒ Any

    Abstracts away resolution of macro runtimes.

    Abstracts away resolution of macro runtimes.

    Definition Classes
      MacroRuntimes

43. #### case class MacroRuntimeAttachment(delayed: Boolean, typerContext: Analyzer.Context, macroContext: Option[Analyzer.MacroContext]) extends Product with Serializable

    Definition Classes
      StdAttachments

44. #### class MacroRuntimeResolver extends tools.nsc.typechecker.Analyzer.JavaReflectionResolvers

    Definition Classes
      MacroRuntimes

45. #### sealed abstract class MacroStatus extends AnyRef

    Definition Classes
      Macros

46. #### trait MethodSynth extends AnyRef

    There are two key methods in here.

    There are two key methods in here.

    1) Enter methods such as enterGetterSetter are called from Namer with a tree which may generate further trees such as accessors or implicit wrappers. Some setup is performed. In general this creates symbols and enters them into the scope of the owner.

    2) addDerivedTrees is called from Typer when a Template is typed. It completes the job, returning a list of trees with their symbols set to those created in the enter methods. Those trees then become part of the typed template.

    Definition Classes
      MethodSynthesis

47. #### case class NamedApplyInfo(qual: Option[Global.Tree], targs: List[Global.Tree], vargss: List[List[Global.Tree]], blockTyper: Analyzer.Typer) extends Product with Serializable

    Definition Classes
      NamesDefaults

48. #### abstract class Namer extends Analyzer.MethodSynth with Analyzer.NamerContextErrors

    Definition Classes
      Namers

49. #### trait NamerContextErrors extends AnyRef

    Definition Classes
      ContextErrors

50. #### class NoInstance extends Throwable with ControlThrowable

    Definition Classes
      Infer

51. #### case class NormalTypeError(underlyingTree: Global.Tree, errMsg: String) extends Analyzer.TreeTypeError with Product with Serializable

    Definition Classes
      ContextErrors

52. #### class NormalTypeErrorFromCyclicReference extends Analyzer.NormalTypeError

    Marks a TypeError that was constructed from a CyclicReference (under silent).

    Marks a TypeError that was constructed from a CyclicReference (under silent). This is used for named arguments, where we need to know if an assignment expression failed with a cyclic reference or some other type error.

    Definition Classes
      ContextErrors

53. #### case class OpenImplicit(info: Analyzer.ImplicitInfo, pt: Global.Type, tree: Global.Tree) extends Product with Serializable

    A class which is used to track pending implicits to prevent infinite implicit searches.

    A class which is used to track pending implicits to prevent infinite implicit searches.

    Definition Classes
      Implicits

54. #### trait PatternTyper extends AnyRef

    Definition Classes
      PatternTypers

55. #### class Phase extends InfoTransform.Phase

    Definition Classes
      InfoTransform

56. #### class PolyTypeCompleter extends Analyzer.TypeCompleter with Analyzer.LockingTypeCompleter with Global.FlagAgnosticCompleter

    A class representing a lazy type with known type parameters.

    A class representing a lazy type with known type parameters. `ctx` is the namer context in which the `owner` is defined.

    Constructing a PolyTypeCompleter for a DefDef creates type skolems for the type parameters and assigns them to the `tparams` trees.

    Definition Classes
      Namers

57. #### case class PosAndMsgTypeError(errPos: Global.Position, errMsg: String) extends Analyzer.AbsTypeError with Product with Serializable

    Definition Classes
      ContextErrors

58. #### class ScalaErasureMap extends ErasureMap

    Definition Classes
      Erasure

59. #### class SearchResult extends AnyRef

    The result of an implicit search

    The result of an implicit search

    Definition Classes
      Implicits

60. #### sealed abstract class SilentResult[+T] extends AnyRef

    Definition Classes
      Typers

61. #### case class SilentResultValue[+T](value: T) extends Analyzer.SilentResult[T] with Product with Serializable

    Definition Classes
      Typers

62. #### class SilentTypeError extends Analyzer.SilentResult[Nothing]

    Definition Classes
      Typers

63. #### case class Skipped(skipped: Global.Tree) extends Analyzer.MacroStatus with Product with Serializable

    Definition Classes
      Macros

64. #### abstract class StdPhase extends GlobalPhase

    A standard phase template

    A standard phase template

    Definition Classes
      SubComponent

65. #### case class Success(expanded: Global.Tree) extends Analyzer.MacroStatus with Product with Serializable

    Definition Classes
      Macros

66. #### case class SuperArgsAttachment(argss: List[List[Global.Tree]]) extends Product with Serializable

    After being synthesized by the parser, primary constructors aren't fully baked yet.

    After being synthesized by the parser, primary constructors aren't fully baked yet. A call to super in such constructors is just a fill-me-in-later dummy resolved later by `parentTypes`. This attachment coordinates `parentTypes` and `typedTemplate` and allows them to complete the synthesis.

    Definition Classes
      StdAttachments

67. #### case class SymbolTypeError(underlyingSym: Global.Symbol, errMsg: String) extends Analyzer.AbsTypeError with Product with Serializable

    Definition Classes
      ContextErrors

68. #### trait Tag extends AnyRef

    Definition Classes
      Tags

69. #### sealed abstract class TreeTypeError extends Analyzer.AbsTypeError

    Definition Classes
      ContextErrors

70. #### trait TypeAdapter extends AnyRef

    Definition Classes
      TypeAdaptingTransformer

71. #### abstract class TypeCompleter extends Global.LazyType

    Definition Classes
      Namers

72. #### case class TypeDiag(tp: Global.Type, sym: Global.Symbol) extends Ordered[Analyzer.TypeDiag] with Product with Serializable

    Definition Classes
      TypeDiagnostics

73. #### case class TypeErrorWithUnderlyingTree(tree: Global.Tree, ex: Global.TypeError) extends Analyzer.AbsTypeError with Product with Serializable

    Definition Classes
      ContextErrors

74. #### case class TypeErrorWrapper(ex: Global.TypeError) extends Analyzer.AbsTypeError with Product with Serializable

    Definition Classes
      ContextErrors

75. #### abstract class Typer extends Analyzer.TyperDiagnostics with Analyzer.Adaptation with Analyzer.Tag with Analyzer.PatternTyper with Analyzer.TyperContextErrors

    Definition Classes
      Typers

76. #### trait TyperContextErrors extends AnyRef

    Definition Classes
      ContextErrors

77. #### trait TyperDiagnostics extends AnyRef

    Definition Classes
      TypeDiagnostics

78. #### abstract class TypingTransformer extends Global.Transformer

    Definition Classes
      TypingTransformers

79. #### type UnaffiliatedMacroContext = reflect.macros.contexts.Context

    Carries information necessary to expand the host tree.

    Carries information necessary to expand the host tree. At times we need to store this info, because macro expansion can be delayed until its targs are inferred. After a macro application has been successfully expanded, this attachment is destroyed.

    Definition Classes
      StdAttachments

80. #### class UnknownSig extends Exception

    Definition Classes
      Erasure

### Value Members

1. #### final def !=(arg0: Any): Boolean

   Test two objects for inequality.

   Test two objects for inequality.

   returns

     `true` if !(this == that), false otherwise.

   Definition Classes
     AnyRef → Any

2. #### final def ##(): Int

   Equivalent to `x.hashCode` except for boxed numeric types and `null`.

   Equivalent to `x.hashCode` except for boxed numeric types and `null`. For numerics, it returns a hash value which is consistent with value equality: if two value type instances compare as true, then ## will produce the same hash value for each of them. For `null` returns a hashcode where `null.hashCode` throws a `NullPointerException`.

   returns

     a hash value consistent with ==

   Definition Classes
     AnyRef → Any

3. #### final def ==(arg0: Any): Boolean

   The expression `x == that` is equivalent to `if (x eq null) that eq null else x.equals(that)`.

   The expression `x == that` is equivalent to `if (x eq null) that eq null else x.equals(that)`.

   arg0

     the object to compare against this object for equality.

   returns

     `true` if the receiver object is equivalent to the argument; `false` otherwise.

   Definition Classes
     AnyRef → Any

4. #### lazy val AmbiguousSearchFailure: SearchResult

   Definition Classes
     Implicits

5. #### object CODE

   Definition Classes
     TreeDSL

6. #### def Delay(expanded: Global.Tree): Delayed

   Definition Classes
     Macros

7. #### lazy val DivergentSearchFailure: SearchResult

   Definition Classes
     Implicits

8. #### object DynamicRewriteAttachment extends Product with Serializable

   Since mkInvoke, the applyDynamic/selectDynamic/etc desugarer, is disconnected from typedNamedApply, the applyDynamicNamed argument rewriter, the latter doesn’t know whether it needs to apply the rewriting because the application has just been desugared or it needs to hold on because it’s already performed a desugaring on this tree.

   Since mkInvoke, the applyDynamic/selectDynamic/etc desugarer, is disconnected from typedNamedApply, the applyDynamicNamed argument rewriter, the latter doesn’t know whether it needs to apply the rewriting because the application has just been desugared or it needs to hold on because it’s already performed a desugaring on this tree. This has led to SI-8006.

   This attachment solves the problem by providing a means of communication between the two Dynamic desugarers, which solves the aforementioned issue.

   Definition Classes
     StdAttachments

9. #### object ErrorUtils

   Definition Classes
     ContextErrors

10. #### object Function1

    An extractor for unary function types arg => res

    An extractor for unary function types arg => res

    Definition Classes
      Implicits

11. #### object GenericArray

    Definition Classes
      Erasure

12. #### object HasMember

    An extractor for types of the form ? { name: ? }

    An extractor for types of the form ? { name: ? }

    Definition Classes
      Implicits

13. #### object HasMethodMatching

    An extractor for types of the form ? { name: (? >: argtpe <: Any*)restp }

    An extractor for types of the form ? { name: (? >: argtpe <: Any*)restp }

    Definition Classes
      Implicits

14. #### object HasUnapply

    Definition Classes
      Unapplies

15. #### object ImplicitNotFoundMsg

    Definition Classes
      Implicits

16. #### val ImportType: Global.ImportType.type

    Definition Classes
      Contexts

17. #### def MacroCantExpand210xMacrosError(internalMessage: String): Nothing

    Definition Classes
      ContextErrors

18. #### def MacroCantExpandIncompatibleMacrosError(internalMessage: String): Nothing

    Definition Classes
      ContextErrors

19. #### object MacroImplBinding extends Serializable

    Definition Classes
      Macros

20. #### object MacroImplRefAttachment extends Product with Serializable

    Definition Classes
      StdAttachments
    See also

      markMacroImplRef

21. #### object NamesDefaultsErrorsGen

    Definition Classes
      ContextErrors

22. #### object NoContext extends Analyzer.Context

    Definition Classes
      Contexts

23. #### def NoImplicitFoundError(tree: Global.Tree, param: Global.Symbol)(implicit context: Context): Unit

    Definition Classes
      ContextErrors

24. #### val NoImplicitInfo: ImplicitInfo

    A sentinel indicating no implicit was found

    A sentinel indicating no implicit was found

    Definition Classes
      Implicits

25. #### lazy val SearchFailure: SearchResult

    Definition Classes
      Implicits

26. #### object SilentTypeError

    Definition Classes
      Typers

27. #### def Skip(expanded: Global.Tree): Skipped

    Definition Classes
      Macros

28. #### object SuppressMacroExpansionAttachment extends Product with Serializable

    When present, suppresses macro expansion for the host.

    When present, suppresses macro expansion for the host. This is occasionally necessary, e.g. to prohibit eta-expansion of macros.

    Does not affect expandability of child nodes, there's context.withMacrosDisabled for that (but think thrice before using that API - see the discussion at https://github.com/scala/scala/pull/1639).

    Definition Classes
      StdAttachments

29. #### var _lockedCount: Int

    Definition Classes
      Namers

30. #### var _openMacros: collection.immutable.List[reflect.macros.contexts.Context { val universe: scala.tools.nsc.Global.erasure.global.type }]

    Keeps track of macros in-flight.

    Keeps track of macros in-flight. See more informations in comments to `openMacros` in `scala.reflect.macros.whitebox.Context`.

    Definition Classes
      Macros

31. #### def abstractVarMessage(sym: Global.Symbol): String

    An explanatory note to be added to error messages when there's a problem with abstract var defs

    An explanatory note to be added to error messages when there's a problem with abstract var defs

    Definition Classes
      TypeDiagnostics

32. #### def adaptAnnotations(tree: Global.Tree, typer: Typer, mode: Mode, pt: Global.Type): Global.Tree

    Definition Classes
      AnalyzerPlugins
    See also

      AnalyzerPlugin.adaptAnnotations

33. #### def addAnalyzerPlugin(plugin: AnalyzerPlugin): Unit

    Registers a new analyzer plugin

    Registers a new analyzer plugin

    Definition Classes
      AnalyzerPlugins

34. #### def addDefaults(givenArgs: List[Global.Tree], qual: Option[Global.Tree], targs: List[Global.Tree], previousArgss: List[List[Global.Tree]], params: List[Global.Symbol], pos: reflect.internal.util.Position, context: Context): (List[Global.Tree], List[Global.Symbol])

    Extend the argument list `givenArgs` with default arguments.

    Extend the argument list `givenArgs` with default arguments. Defaults are added as named arguments calling the corresponding default getter.

    Example: given def foo(x: Int = 2, y: String = "def") foo(y = "lt") the argument list (y = "lt") is transformed to (y = "lt", x = foo$default$1())

    Definition Classes
      NamesDefaults

35. #### def addMacroPlugin(plugin: MacroPlugin): Unit

    Registers a new macro plugin

    Registers a new macro plugin

    Definition Classes
      AnalyzerPlugins

36. #### def addSyntheticMethods(templ: Global.Template, clazz0: Global.Symbol, context: Context): Global.Template

    Add the synthetic methods to case classes.

    Add the synthetic methods to case classes.

    Definition Classes
      SyntheticMethods

37. #### final def afterOwnPhase[T](op: ⇒ T): T

    Definition Classes
      SubComponent
    Annotations
      @inline()

38. #### def allArgsArePositional(a: Array[Int]): Boolean

    returns `true` if every element is equal to its index

    returns `true` if every element is equal to its index

    Definition Classes
      NamesDefaults

39. #### def allViewsFrom(tp: Global.Type, context: Context, tpars: List[Global.Symbol]): List[(SearchResult, List[Global.TypeConstraint])]

    Find all views from type `tp` (in which `tpars` are free)

    Find all views from type `tp` (in which `tpars` are free)

    Note that the trees in the search results in the returned list share the same type variables. Ignore their constr field! The list of type constraints returned along with each tree specifies the constraints that must be met by the corresponding type parameter in `tpars` (for the returned implicit view to be valid).

    Definition Classes
      Implicits

40. #### def alternatives(tree: Global.Tree): List[Global.Type]

    Definition Classes
      TypeDiagnostics

41. #### def alternativesString(tree: Global.Tree): String

    Definition Classes
      TypeDiagnostics

42. #### def ambiguousDefnAndImport(owner: Global.Symbol, imp: ImportInfo): Global.LookupAmbiguous

    Definition Classes
      Contexts

43. #### def ambiguousImports(imp1: ImportInfo, imp2: ImportInfo): Global.LookupAmbiguous

    Definition Classes
      Contexts

44. #### val analyzer: Analyzer { val global: scala.tools.nsc.Global.erasure.global.type }

    Definition Classes
      Erasure → TypeAdaptingTransformer

45. #### final def asInstanceOf[T0]: T0

    Cast the receiver object to be of type `T0`.

    Cast the receiver object to be of type `T0`.

    Note that the success of a cast at runtime is modulo Scala's erasure semantics. Therefore the expression `1.asInstanceOf[String]` will throw a `ClassCastException` at runtime, while the expression `List(1).asInstanceOf[List[String]]` will not. In the latter example, because the type argument is erased as part of compilation it is not possible to check whether the contents of the list are of the requested type.

    returns

      the receiver object.

    Definition Classes
      Any
    Exceptions thrown

      `ClassCastException` if the receiver object is not an instance of the erasure of type `T0`.

46. #### final def beforeOwnPhase[T](op: ⇒ T): T

    Definition Classes
      SubComponent
    Annotations
      @inline()

47. #### def bindMacroImpl(macroDef: Global.Symbol, macroImplRef: Global.Tree): Unit

    Definition Classes
      Macros

48. #### def canAdaptAnnotations(tree: Global.Tree, typer: Typer, mode: Mode, pt: Global.Type): Boolean

    Definition Classes
      AnalyzerPlugins
    See also

      AnalyzerPlugin.canAdaptAnnotations

49. #### final def caseAccessorName(caseclazz: Global.Symbol, paramName: Global.TermName): Global.TermName

    Does not force the info of `caseclazz`

    Does not force the info of `caseclazz`

    Definition Classes
      SyntheticMethods

50. #### def caseClassCopyMeth(cdef: Global.ClassDef): Option[Global.DefDef]

    Generates copy methods for case classes.

    Generates copy methods for case classes. Copy only has defaults on the first parameter list, as of SI-5009.

    The parameter types of the copy method need to be exactly the same as the parameter types of the primary constructor. Just copying the TypeTree is not enough: a type `C` might refer to something else *inside* the class (i.e. as parameter type of `copy`) than *outside* the class (i.e. in the class parameter list).

    One such example is t0054.scala: class A { case class B(x: C) extends A { def copy(x: C = x) = ... } class C {} } (1) (2)

    The reference (1) to C is `A.this.C`. The reference (2) is `B.this.C` - not the same.

    This is fixed with a hack currently. `Unapplies.caseClassCopyMeth`, which creates the copy method, uses empty `TypeTree()` nodes for parameter types.

    In `Namers.enterDefDef`, the copy method gets a special type completer (`enterCopyMethod`). Before computing the body type of `copy`, the class parameter types are assigned the copy method parameters.

    This attachment class stores the copy method parameter ValDefs as an attachment in the ClassDef of the case class.

    Definition Classes
      Unapplies

51. #### def caseModuleApplyMeth(cdef: Global.ClassDef): Global.DefDef

    The apply method corresponding to a case class

    The apply method corresponding to a case class

    Definition Classes
      Unapplies

52. #### def caseModuleDef(cdef: Global.ClassDef): Global.ModuleDef

    The module corresponding to a case class; overrides toString to show the module's name

    The module corresponding to a case class; overrides toString to show the module's name

    Definition Classes
      Unapplies

53. #### def caseModuleUnapplyMeth(cdef: Global.ClassDef): Global.DefDef

    The unapply method corresponding to a case class

    The unapply method corresponding to a case class

    Definition Classes
      Unapplies

54. #### def changesBaseClasses: Boolean

    Attributes
      protected
    Definition Classes
      InfoTransform

55. #### final def clearRenamedCaseAccessors(caseclazz: Global.Symbol): Unit

    Definition Classes
      SyntheticMethods

56. #### def clone(): AnyRef

    Create a copy of the receiver object.

    Create a copy of the receiver object.

    The default implementation of the `clone` method is platform dependent.

    returns

      a copy of the receiver object.

    Attributes
      protected[java.lang]
    Definition Classes
      AnyRef
    Annotations
      @throws( ... )
    Note

      not specified by SLS as a member of AnyRef

57. #### def companionModuleDef(cdef: Global.ClassDef, parents: List[Global.Tree] = Nil, body: List[Global.Tree] = Nil): Global.ModuleDef

    Definition Classes
      Unapplies

58. #### def companionSymbolOf(original: Global.Symbol, ctx: Context): Global.Symbol

    The companion class or companion module of `original`.

    The companion class or companion module of `original`. Calling .companionModule does not work for classes defined inside methods.

    !!! Then why don't we fix companionModule? Does the presence of these methods imply all the places in the compiler calling sym.companionModule are bugs waiting to be reported? If not, why not? When exactly do we need to call this method?

    Definition Classes
      Namers

59. #### def computeMacroDefTypeFromMacroImplRef(macroDdef: Global.DefDef, macroImplRef: Global.Tree): Global.Type

    Definition Classes
      Macros

60. #### def decodeWithKind(name: Global.Name, owner: Global.Symbol): String

    Definition Classes
      TypeDiagnostics

61. #### val deconstMap: Global.TypeMap

    Definition Classes
      Erasure

62. #### def decreaseMetalevel(tp: Global.Type): Global.Type

    Decreases metalevel of the type, i.e.

    Decreases metalevel of the type, i.e. transforms: * c.Expr[T] to T * Nothing to Nothing * Anything else to NoType

    Definition Classes
      Helpers
    See also

      Metalevels.scala for more information and examples about metalevels

63. #### def defaultGetter(param: Global.Symbol, context: Context): Global.Symbol

    For a parameter with default argument, find the method symbol of the default getter.

    For a parameter with default argument, find the method symbol of the default getter.

    Definition Classes
      NamesDefaults

64. #### lazy val defaultMacroClassloader: ClassLoader

    Macro classloader that is used to resolve and run macro implementations.

    Macro classloader that is used to resolve and run macro implementations. Loads classes from from -cp (aka the library classpath). Is also capable of detecting REPL and reusing its classloader.

    When -Xmacro-jit is enabled, we sometimes fallback to on-the-fly compilation of macro implementations, which compiles implementations into a virtual directory (very much like REPL does) and then conjures a classloader mapped to that virtual directory.

    Definition Classes
      MacroRuntimes

65. #### def deriveAnnotations(initial: List[Global.AnnotationInfo], category: Global.Symbol, keepClean: Boolean): List[Global.AnnotationInfo]

    The annotations amongst those found on the original symbol which should be propagated to this kind of accessor.

    The annotations amongst those found on the original symbol which should be propagated to this kind of accessor.

    Definition Classes
      MethodSynthesis

66. #### def directUnapplyMember(tp: Global.Type): Global.Symbol

    Returns unapply or unapplySeq if available, without further checks.

    Returns unapply or unapplySeq if available, without further checks.

    Definition Classes
      Unapplies

67. #### def disambiguate(ss: List[String]): collection.immutable.List[String]

    Definition Classes
      TypeDiagnostics

68. #### def enabled: Boolean

    Is this component enabled? Default is true.

    Is this component enabled? Default is true.

    Definition Classes
      SubComponent

69. #### def enclosingMacroPosition: reflect.internal.util.Position

    Definition Classes
      Macros

70. #### final def eq(arg0: AnyRef): Boolean

    Tests whether the argument (`arg0`) is a reference to the receiver object (`this`).

    Tests whether the argument (`arg0`) is a reference to the receiver object (`this`).

    The `eq` method implements an equivalence relation on non-null instances of `AnyRef`, and has three additional properties:

    - It is consistent: for any non-null instances `x` and `y` of type `AnyRef`, multiple invocations of `x.eq(y)` consistently returns `true` or consistently returns `false`.
    - For any non-null instance `x` of type `AnyRef`, `x.eq(null)` and `null.eq(x)` returns `false`.
    - `null.eq(null)` returns `true`.

    When overriding the `equals` or `hashCode` methods, it is important to ensure that their behavior is consistent with reference equality. Therefore, if two objects are references to each other (`o1 eq o2`), they should be equal to each other (`o1 == o2`) and they should hash to the same value (`o1.hashCode == o2.hashCode`).

    returns

      `true` if the argument is a reference to the receiver object; `false` otherwise.

    Definition Classes
      AnyRef

71. #### def equals(arg0: Any): Boolean

    The equality method for reference types.

    The equality method for reference types. Default implementation delegates to `eq`.

    See also `equals` in scala.Any.

    returns

      `true` if the receiver object is equivalent to the argument; `false` otherwise.

    Definition Classes
      AnyRef → Any

72. #### def erasedValueClassArg(tref: Global.TypeRef): Global.Type

    Definition Classes
      Erasure

73. #### def erasure(sym: Global.Symbol): ErasureMap

    Definition Classes
      Erasure

74. #### def etaExpand(unit: Global.CompilationUnit, tree: Global.Tree, typer: Typer): Global.Tree

    Expand partial function applications of type `type`.

    Expand partial function applications of type `type`.

         p.f(es_1)...(es_n)
            ==>  {
                   private synthetic val eta$f   = p.f   // if p is not stable
                   ...
                   private synthetic val eta$e_i = e_i    // if e_i is not stable
                   ...
                   (ps_1 => ... => ps_m => eta$f([es_1])...([es_m])(ps_1)...(ps_m))
                 }

    tree is already attributed

    Definition Classes
      EtaExpansion

75. #### object etaExpansion

    Definition Classes
      EtaExpansion

76. #### final def exampleTuplePattern(names: List[Global.Name]): String

    [a, b, c] => "(a, b, c)" [a, B] => "(param1, param2)" [a, B, c] => "(param1, ..., param2)"

    [a, b, c] => "(a, b, c)" [a, B] => "(param1, param2)" [a, B, c] => "(param1, ..., param2)"

    Definition Classes
      TypeDiagnostics

77. #### def existentialContext(tp: Global.Type): String

    Definition Classes
      TypeDiagnostics

78. #### def explainAlias(tp: Global.Type): String

    Definition Classes
      TypeDiagnostics

79. #### def explainAnyVsAnyRef(found: Global.Type, req: Global.Type): String

    Definition Classes
      TypeDiagnostics

80. #### def explainVariance(found: Global.Type, req: Global.Type): String

    Look through the base types of the found type for any which might have been valid subtypes if given conformant type arguments.

    Look through the base types of the found type for any which might have been valid subtypes if given conformant type arguments. Examine those for situations where the type error would have been eliminated if the variance were different. In such cases, append an additional explanatory message.

    TODO: handle type aliases better.

    Definition Classes
      TypeDiagnostics

81. #### def factoryMeth(mods: Global.Modifiers, name: Global.TermName, cdef: Global.ClassDef): Global.DefDef

    The apply method corresponding to a case class

    The apply method corresponding to a case class

    Definition Classes
      Unapplies

82. #### final def falseIfNoInstance(body: ⇒ Boolean): Boolean

    Definition Classes
      Infer
    Annotations
      @inline()

83. #### lazy val fastTrack: FastTrack[Global.erasure.this.type]

    Definition Classes
      Macros

84. #### def finalize(): Unit

    Called by the garbage collector on the receiver object when there are no more references to the object.

    Called by the garbage collector on the receiver object when there are no more references to the object.

    The details of when and if the `finalize` method is invoked, as well as the interaction between `finalize` and non-local returns and exceptions, are all platform dependent.

    Attributes
      protected[java.lang]
    Definition Classes
      AnyRef
    Annotations
      @throws( classOf[java.lang.Throwable] )
    Note

      not specified by SLS as a member of AnyRef

85. #### def findMacroClassLoader(): ClassLoader

    Attributes
      protected
    Definition Classes
      Macros

86. #### final def forArgMode(fun: Global.Tree, mode: Mode): reflect.internal.Mode

    Definition Classes
      Typers

87. #### def formalTypes(formals: List[Global.Type], numArgs: Int, removeByName: Boolean = true, removeRepeated: Boolean = true): List[Global.Type]

    The formal parameter types corresponding to `formals`.

    The formal parameter types corresponding to `formals`. If `formals` has a repeated last parameter, a list of (numArgs - numFormals + 1) copies of its type is appended to the other formals. By-name types are replaced with their underlying type.

    removeByName

      allows keeping ByName parameters. Used in NamesDefaults.

    removeRepeated

      allows keeping repeated parameter (if there's one argument). Used in NamesDefaults.

    Definition Classes
      Infer

88. #### def foundReqMsg(found: Global.Type, req: Global.Type): String

    Definition Classes
      TypeDiagnostics

89. #### def freshVar(tparam: Global.Symbol): Global.TypeVar

    A fresh type variable with given type parameter as origin.

    A fresh type variable with given type parameter as origin.

    Definition Classes
      Infer

90. #### def fullSiteString(context: Context): String

    Definition Classes
      TypersTracking

91. #### final def getClass(): Class[_]

    A representation that corresponds to the dynamic class of the receiver object.

    A representation that corresponds to the dynamic class of the receiver object.

    The nature of the representation is platform dependent.

    returns

      a representation that corresponds to the dynamic class of the receiver object.

    Definition Classes
      AnyRef → Any
    Note

      not specified by SLS as a member of AnyRef

92. #### val global: Global.this.type

    The global environment; overridden by instantiation in Global.

    The global environment; overridden by instantiation in Global.

    Definition Classes
      erasure → TypingTransformers → Analyzer → TreeDSL → Erasure → SubComponent

93. #### def globalSettings: Settings

    Definition Classes
      Macros → Traces

94. #### def hasMacroExpansionAttachment(any: Any): Boolean

    Determines whether the target is either an original or a result of a macro expansion.

    Determines whether the target is either an original or a result of a macro expansion. The parameter is of type `Any`, because macros can expand both into trees and into annotations.

    Definition Classes
      StdAttachments

95. #### var hasPendingMacroExpansions: Boolean

    Without any restrictions on macro expansion, macro applications will expand at will, and when type inference is involved, expansions will end up using yet uninferred type params.

    Without any restrictions on macro expansion, macro applications will expand at will, and when type inference is involved, expansions will end up using yet uninferred type params.

    For some macros this might be ok (thanks to TreeTypeSubstituter that replaces the occurrences of undetparams with their inferred values), but in general case this won't work. E.g. for reification simple substitution is not enough - we actually need to re-reify inferred types.

    Luckily, there exists a very simple way to fix the problem: delay macro expansion until everything is inferred. Here are the exact rules. Macro application gets delayed if any of its subtrees contain: 1) type vars (tpe.isInstanceOf[TypeVar]) // [Eugene] this check is disabled right now, because TypeVars seem to be created from undetparams anyways 2) undetparams (sym.isTypeParameter && !sym.isSkolem)

    Definition Classes
      Macros

96. #### def hasSuperArgs(tree: Global.Tree): Boolean

    Determines whether the given tree has an associated SuperArgsAttachment.

    Determines whether the given tree has an associated SuperArgsAttachment.

    Definition Classes
      StdAttachments

97. #### def hashCode(): Int

    SubComponent are added to a HashSet and two phases are the same if they have the same name

    SubComponent are added to a HashSet and two phases are the same if they have the same name

    returns

      the hash code value for this object.

    Definition Classes
      SubComponent → AnyRef → Any

98. #### def implClass(iface: Global.Symbol): Global.Symbol

    Return the implementation class of a trait; create a new one of one does not yet exist

    Return the implementation class of a trait; create a new one of one does not yet exist

    Definition Classes
      AddInterfaces

99. #### def implClassDefs(trees: List[Global.Tree]): List[Global.Tree]

    Definition Classes
      AddInterfaces

100. #### def implClassPhase: reflect.internal.Phase

     Definition Classes
       AddInterfaces

101. #### def increaseMetalevel(pre: Global.Type, tp: Global.Type): Global.Type

     Increases metalevel of the type, i.e.

     Increases metalevel of the type, i.e. transforms: * T to c.Expr[T]

     Definition Classes
       Helpers
     See also

       Metalevels.scala for more information and examples about metalevels

102. #### def inferImplicit(tree: Global.Tree, pt: Global.Type, isView: Boolean, context: Context, silent: Boolean, withMacrosDisabled: Boolean, pos: Global.Position, onError: (Global.Position, String) ⇒ Unit): Global.Tree

     A friendly wrapper over inferImplicit to be used in macro contexts and toolboxes.

     A friendly wrapper over inferImplicit to be used in macro contexts and toolboxes.

     Definition Classes
       Implicits

103. #### def inferImplicit(tree: Global.Tree, pt: Global.Type, reportAmbiguous: Boolean, isView: Boolean, context: Context, saveAmbiguousDivergent: Boolean, pos: Global.Position): SearchResult

     Search for an implicit value.

     Search for an implicit value. See the comment on `result` at the end of class `ImplicitSearch` for more info how the search is conducted.

     tree

       The tree for which the implicit needs to be inserted. (the inference might instantiate some of the undetermined type parameters of that tree.

     pt

       The expected type of the implicit.

     reportAmbiguous

       Should ambiguous implicit errors be reported? False iff we search for a view to find out whether one type is coercible to another.

     isView

       We are looking for a view

     context

       The current context

     saveAmbiguousDivergent

       False if any divergent/ambiguous errors should be ignored after implicits search, true if they should be reported (used in further typechecking).

     pos

       Position that is should be used for tracing and error reporting (useful when we infer synthetic stuff and pass EmptyTree in the `tree` argument) If it's set NoPosition, then position-based services will use `tree.pos`

     returns

       A search result

     Definition Classes
       Implicits

104. #### def inferImplicit(tree: Global.Tree, pt: Global.Type, reportAmbiguous: Boolean, isView: Boolean, context: Context, saveAmbiguousDivergent: Boolean): SearchResult

     Definition Classes
       Implicits

105. #### def inferImplicit(tree: Global.Tree, pt: Global.Type, reportAmbiguous: Boolean, isView: Boolean, context: Context): SearchResult

     Definition Classes
       Implicits

106. #### val initial: Boolean

     True if this phase runs before all other phases.

     True if this phase runs before all other phases. Usually, `parser`.

     Definition Classes
       SubComponent

107. #### object instantiate extends Global.TypeMap

     Map every TypeVar to its constraint.inst field.

     Map every TypeVar to its constraint.inst field. throw a NoInstance exception if a NoType or WildcardType is encountered.

     Definition Classes
       Infer

108. #### val internal: Boolean

     True if this phase is not provided by a plug-in.

     True if this phase is not provided by a plug-in.

     Definition Classes
       SubComponent

109. #### def intersectionDominator(parents: List[Global.Type]): Global.Type

     Definition Classes
       Erasure

110. #### def isBlackbox(macroDef: Global.Symbol): Boolean

     Definition Classes
       Macros

111. #### def isBlackbox(expandee: Global.Tree): Boolean

     Definition Classes
       Macros

112. #### def isDynamicRewrite(tree: Global.Tree): Boolean

     Definition Classes
       StdAttachments

113. #### final def isInstanceOf[T0]: Boolean

     Test whether the dynamic type of the receiver object is `T0`.

     Test whether the dynamic type of the receiver object is `T0`.

     Note that the result of the test is modulo Scala's erasure semantics. Therefore the expression `1.isInstanceOf[String]` will return `false`, while the expression `List(1).isInstanceOf[List[String]]` will return `true`. In the latter example, because the type argument is erased as part of compilation it is not possible to check whether the contents of the list are of the specified type.

     returns

       `true` if the receiver object is an instance of erasure of type `T0`; `false` otherwise.

     Definition Classes
       Any

114. #### def isMacroExpansionSuppressed(tree: Global.Tree): Boolean

     Determines whether a tree should not be expanded, because someone has put SuppressMacroExpansionAttachment on it or one of its children.

     Determines whether a tree should not be expanded, because someone has put SuppressMacroExpansionAttachment on it or one of its children.

     Definition Classes
       StdAttachments

115. #### def isMacroImplRef(tree: Global.Tree): Boolean

     Determines whether a tree should or should not be adapted, because someone has put MacroImplRefAttachment on it.

     Determines whether a tree should or should not be adapted, because someone has put MacroImplRefAttachment on it.

     Definition Classes
       StdAttachments

116. #### def isNamedArg(arg: Global.Tree): Boolean

     Definition Classes
       NamesDefaults

117. #### def javaSig(sym0: Global.Symbol, info: Global.Type): Option[String]

     The Java signature of type 'info', for symbol sym.

     The Java signature of type 'info', for symbol sym. The symbol is used to give the right return type for constructors.

     Definition Classes
       Erasure

118. #### def keepsTypeParams: Boolean

     Definition Classes
       Erasure → InfoTransform

119. #### var lastAccessCheckDetails: String

     Definition Classes
       Contexts

120. #### var lastTreeToTyper: Global.Tree

     Definition Classes
       TypersTracking

121. #### def linePrecedes(t1: Global.Tree, t2: Global.Tree): Boolean

     Definition Classes
       TypeDiagnostics

122. #### def linkExpandeeAndDesugared(expandee: Global.Tree, desugared: Global.Tree): Unit

     After macro expansion is completed, links the expandee and the expansion result by annotating them both with a `MacroExpansionAttachment`.

     After macro expansion is completed, links the expandee and the expansion result by annotating them both with a `MacroExpansionAttachment`.

     Definition Classes
       StdAttachments

123. #### def linkExpandeeAndExpanded(expandee: Global.Tree, expanded: Any): Unit

     After macro expansion is completed, links the expandee and the expansion result by annotating them both with a `MacroExpansionAttachment`.

     After macro expansion is completed, links the expandee and the expansion result by annotating them both with a `MacroExpansionAttachment`. The `expanded` parameter is of type `Any`, because macros can expand both into trees and into annotations.

     Definition Classes
       StdAttachments

124. #### final def linkedClassOfClassOf(original: Global.Symbol, ctx: Context): Global.Symbol

     A version of `Symbol#linkedClassOfClass` that works with local companions, ala `companionSymbolOf`.

     A version of `Symbol#linkedClassOfClass` that works with local companions, ala `companionSymbolOf`.

     Definition Classes
       Namers

125. #### def loadMacroImplBinding(macroDef: Global.Symbol): Option[MacroImplBinding]

     Definition Classes
       Macros

126. #### def lockedCount: Int

     Definition Classes
       Namers

127. #### def macroArgs(typer: Typer, expandee: Global.Tree): MacroArgs

     Definition Classes
       Macros

128. #### def macroContext(typer: Typer, prefixTree: Global.Tree, expandeeTree: Global.Tree): MacroContext

     Definition Classes
       Macros

129. #### val macroDebugLite: Boolean

     Definition Classes
       Traces

130. #### val macroDebugVerbose: Boolean

     Definition Classes
       Traces

131. #### def macroEngine: String

     Macro def -> macro impl bindings are serialized into a `macroImpl` annotation with synthetic content that carries the payload described in `MacroImplBinding`.

     Macro def -> macro impl bindings are serialized into a `macroImpl` annotation with synthetic content that carries the payload described in `MacroImplBinding`.

     For example, for a pair of macro definition and macro implementation: def impl(c: scala.reflect.macros.blackbox.Context): c.Expr[Unit] = ??? def foo: Unit = macro impl

     We will have the following annotation added on the macro definition `foo`:

     Definition Classes
       Macros

132. #### def macroExpand(typer: Typer, expandee: Global.Tree, mode: Mode, pt: Global.Type): Global.Tree

     Expands a term macro used in apply role as `M(2)(3)` in `val x = M(2)(3)`.

     Expands a term macro used in apply role as `M(2)(3)` in `val x = M(2)(3)`.

     Definition Classes
       Macros
     See also

       DefMacroExpander

133. #### def macroExpandAll(typer: Typer, expandee: Global.Tree): Global.Tree

     Performs macro expansion on all subtrees of a given tree.

     Performs macro expansion on all subtrees of a given tree. Innermost macros are expanded first, outermost macros are expanded last. See the documentation for `macroExpand` for more information.

     Definition Classes
       Macros

134. #### def macroExpandWithRuntime(typer: Typer, expandee: Global.Tree, runtime: MacroRuntime): MacroStatus

     Expands a macro when a runtime (i.e.

     Expands a macro when a runtime (i.e. the macro implementation) can be successfully loaded Meant for internal use within the macro infrastructure, don't use it elsewhere.

     Definition Classes
       Macros

135. #### def macroExpandWithoutRuntime(typer: Typer, expandee: Global.Tree): MacroStatus

     Expands a macro when a runtime (i.e.

     Expands a macro when a runtime (i.e. the macro implementation) cannot be loaded Meant for internal use within the macro infrastructure, don't use it elsewhere.

     Definition Classes
       Macros

136. #### def macroExpandee(tree: Global.Tree): Global.Tree

     Returns the original tree of the macro expansion if the argument is a macro expansion or EmptyTree otherwise.

     Returns the original tree of the macro expansion if the argument is a macro expansion or EmptyTree otherwise.

     Definition Classes
       StdAttachments

137. #### def macroExpanderAttachment(tree: Global.Tree): MacroExpanderAttachment

     Loads underlying MacroExpanderAttachment from a macro expandee or returns a default value for that attachment.

     Loads underlying MacroExpanderAttachment from a macro expandee or returns a default value for that attachment.

     Definition Classes
       StdAttachments

138. #### final def macroLogLite(msg: ⇒ Any): Unit

     Definition Classes
       Traces
     Annotations
       @inline()

139. #### final def macroLogVerbose(msg: ⇒ Any): Unit

     Definition Classes
       Traces
     Annotations
       @inline()

140. #### def macroRuntime(expandee: Global.Tree): MacroRuntime

     Produces a function that can be used to invoke macro implementation for a given macro definition: 1) Looks up macro implementation symbol in this universe.

     Produces a function that can be used to invoke macro implementation for a given macro definition: 1) Looks up macro implementation symbol in this universe. 2) Loads its enclosing class from the macro classloader. 3) Loads the companion of that enclosing class from the macro classloader. 4) Resolves macro implementation within the loaded companion.

     returns

       Requested runtime if macro implementation can be loaded successfully from either of the mirrors, `null` otherwise.

     Definition Classes
       MacroRuntimes

141. #### def makeNamedTypes(syms: List[Global.Symbol]): collection.immutable.List[Global.NamedType]

     Definition Classes
       NamesDefaults

142. #### def markDynamicRewrite(tree: Global.Tree): Global.Tree

     Definition Classes
       StdAttachments

143. #### def markMacroImplRef(tree: Global.Tree): Global.Tree

     Marks the tree as a macro impl reference, which is a naked reference to a method.

     Marks the tree as a macro impl reference, which is a naked reference to a method.

     This is necessary for typechecking macro impl references (see `DefaultMacroCompiler.defaultResolveMacroImpl`), because otherwise typing a naked reference will result in the "follow this method with `_' if you want to treat it as a partially applied function" errors.`

     This mark suppresses adapt except for when the annottee is a macro application.

     Definition Classes
       StdAttachments

144. #### def memberWildcardType(name: Global.Name, tp: Global.Type): Global.Type

     A constructor for types ?{ def/type name: tp }, used in infer view to member searches.

     A constructor for types ?{ def/type name: tp }, used in infer view to member searches.

     Definition Classes
       Implicits

145. #### def minimizeParents(parents: List[Global.Type]): List[Global.Type]

     Definition Classes
       Erasure

146. #### def missingParams[T](args: List[T], params: List[Global.Symbol], argName: (T) ⇒ Option[Global.Name]): (List[Global.Symbol], Boolean)

     Returns the parameter symbols of an invocation expression that are not defined by the list of arguments.

     Returns the parameter symbols of an invocation expression that are not defined by the list of arguments.

     args

       The list of arguments

     params

       The list of parameter symbols of the invoked method

     argName

       A function that extracts the name of an argument expression, if it is a named argument.

     Definition Classes
       NamesDefaults

147. #### val mixinTransformer: Global.Transformer

     Attributes
       protected
     Definition Classes
       AddInterfaces

148. #### def mkTypeCompleter(t: Global.Tree)(c: (Global.Symbol) ⇒ Unit): TypeCompleter with LockingTypeCompleter with Global.FlagAgnosticCompleter

     Definition Classes
       Namers

149. #### object namerFactory extends SubComponent

     Definition Classes
       Analyzer

150. #### final def ne(arg0: AnyRef): Boolean

     Equivalent to `!(this eq that)`.

     Equivalent to `!(this eq that)`.

     returns

       `true` if the argument is not a reference to the receiver object; `false` otherwise.

     Definition Classes
       AnyRef

151. #### def needsJavaSig(tp: Global.Type): Boolean

     Definition Classes
       Erasure

152. #### def newNamer(context: Context): Namer

     Definition Classes
       Namers

153. #### def newPhase(prev: nsc.Phase): StdPhase

     Create a new phase which applies transformer

     Create a new phase which applies transformer

     Definition Classes
       AddInterfaces → InfoTransform → Transform → SubComponent

154. #### def newTransformer(unit: Global.CompilationUnit): Global.Transformer

     The transformer factory

     The transformer factory

     Definition Classes
       Erasure → Transform

155. #### def newTyper(context: Context): Eraser

     Definition Classes
       Erasure → Typers

156. #### def noPrintAdapt(tree1: Global.Tree, tree2: Global.Tree): Boolean

     Definition Classes
       TypersTracking

157. #### def noPrintTyping(t: Global.Tree): Boolean

     Definition Classes
       TypersTracking

158. #### def normalize(tp: Global.Type): Global.Type

     Automatically perform the following conversions on expression types: A method type becomes the corresponding function type.

     Automatically perform the following conversions on expression types: A method type becomes the corresponding function type. A nullary method type becomes its result type. Implicit parameters are skipped. This method seems to be performance critical.

     Definition Classes
       Infer

159. #### def notAnyRefMessage(found: Global.Type): String

     Definition Classes
       ContextErrors

160. #### final def notify(): Unit

     Wakes up a single thread that is waiting on the receiver object's monitor.

     Wakes up a single thread that is waiting on the receiver object's monitor.

     Definition Classes
       AnyRef
     Note

       not specified by SLS as a member of AnyRef

161. #### final def notifyAll(): Unit

     Wakes up all threads that are waiting on the receiver object's monitor.

     Wakes up all threads that are waiting on the receiver object's monitor.

     Definition Classes
       AnyRef
     Note

       not specified by SLS as a member of AnyRef

162. #### def notifyUndetparamsAdded(newUndets: List[Global.Symbol]): Unit

     Definition Classes
       Macros

163. #### def notifyUndetparamsInferred(undetNoMore: List[Global.Symbol], inferreds: List[Global.Type]): Unit

     Definition Classes
       Macros

164. #### def numericConversion(tree: Global.Tree, numericSym: Global.Symbol): Global.Tree

     Definition Classes
       Erasure

165. #### def onTreeCheckerError(pos: Global.Position, msg: String): Unit

     Attributes
       protected
     Definition Classes
       Contexts

166. #### def openMacros: collection.immutable.List[reflect.macros.contexts.Context { val universe: scala.tools.nsc.Global.erasure.global.type }]

     Definition Classes
       Macros

167. #### def ownPhase: nsc.Phase

     The phase corresponding to this subcomponent in the current compiler run

     The phase corresponding to this subcomponent in the current compiler run

     Definition Classes
       SubComponent

168. #### object packageObjects extends SubComponent

     Definition Classes
       Analyzer

169. #### val phaseName: String

     The name of the phase

     The name of the phase

     Definition Classes
       Erasure → SubComponent

170. #### def phaseNewFlags: Long

     The phase sets lateINTERFACE for non-interface traits that now become interfaces.

     The phase sets lateINTERFACE for non-interface traits that now become interfaces. It sets lateDEFERRED for formerly concrete methods in such traits.

     Definition Classes
       AddInterfaces → SubComponent

171. #### def phaseNextFlags: Long

     New flags defined by the phase which are not valid until immediately after it

     New flags defined by the phase which are not valid until immediately after it

     Definition Classes
       SubComponent

172. #### def pluginsEnsureCompanionObject(namer: Namer, cdef: Global.ClassDef, creator: (Global.ClassDef) ⇒ Global.Tree = companionModuleDef(_)): Global.Symbol

     Definition Classes
       AnalyzerPlugins
     See also

       MacroPlugin.pluginsEnsureCompanionObject

173. #### def pluginsEnterStats(typer: Typer, stats: List[Global.Tree]): List[Global.Tree]

     Definition Classes
       AnalyzerPlugins
     See also

       MacroPlugin.pluginsEnterStats

174. #### def pluginsEnterSym(namer: Namer, tree: Global.Tree): Context

     Definition Classes
       AnalyzerPlugins
     See also

       MacroPlugin.pluginsEnterSym

175. #### def pluginsIsBlackbox(macroDef: Global.Symbol): Boolean

     Definition Classes
       AnalyzerPlugins
     See also

       MacroPlugin.pluginsIsBlackbox

176. #### def pluginsMacroArgs(typer: Typer, expandee: Global.Tree): MacroArgs

     Definition Classes
       AnalyzerPlugins
     See also

       MacroPlugin.pluginsMacroArgs

177. #### def pluginsMacroExpand(typer: Typer, expandee: Global.Tree, mode: Mode, pt: Global.Type): Global.Tree

     Definition Classes
       AnalyzerPlugins
     See also

       MacroPlugin.pluginsMacroExpand

178. #### def pluginsMacroRuntime(expandee: Global.Tree): MacroRuntime

     Definition Classes
       AnalyzerPlugins
     See also

       MacroPlugin.pluginsMacroRuntime

179. #### def pluginsPt(pt: Global.Type, typer: Typer, tree: Global.Tree, mode: Mode): Global.Type

     Definition Classes
       AnalyzerPlugins
     See also

       AnalyzerPlugin.pluginsPt

180. #### def pluginsTypeSig(tpe: Global.Type, typer: Typer, defTree: Global.Tree, pt: Global.Type): Global.Type

     Definition Classes
       AnalyzerPlugins
     See also

       AnalyzerPlugin.pluginsTypeSig

181. #### def pluginsTypeSigAccessor(tpe: Global.Type, typer: Typer, tree: Global.ValDef, sym: Global.Symbol): Global.Type

     Definition Classes
       AnalyzerPlugins
     See also

       AnalyzerPlugin.pluginsTypeSigAccessor

182. #### def pluginsTyped(tpe: Global.Type, typer: Typer, tree: Global.Tree, mode: Mode, pt: Global.Type): Global.Type

     Definition Classes
       AnalyzerPlugins
     See also

       AnalyzerPlugin.pluginsTyped

183. #### def pluginsTypedMacroBody(typer: Typer, ddef: Global.DefDef): Global.Tree

     Definition Classes
       AnalyzerPlugins
     See also

       MacroPlugin.pluginsTypedMacroBody

184. #### def pluginsTypedReturn(tpe: Global.Type, typer: Typer, tree: Global.Return, pt: Global.Type): Global.Type

     Definition Classes
       AnalyzerPlugins
     See also

       AnalyzerPlugin.pluginsTypedReturn

185. #### def popMacroContext(): Unit

     Definition Classes
       Macros

186. #### def posPrecedes(p1: Global.Position, p2: Global.Position): Boolean

     Does the positioned line assigned to t1 precede that of t2?

     Does the positioned line assigned to t1 precede that of t2?

     Definition Classes
       TypeDiagnostics

187. #### val prepareSigMap: Global.TypeMap { def squashBoxed(tp: scala.tools.nsc.Global.erasure.global.Type): scala.tools.nsc.Global.erasure.global.Type }

     This object is only used for sanity testing when -check:genjvm is set.

     This object is only used for sanity testing when -check:genjvm is set. In that case we make sure that the erasure of the `normalized` type is the same as the erased type that's generated. Normalization means unboxing some primitive types and further simplifications as they are done in jsig.

     Definition Classes
       Erasure

188. #### def propagateKnownTypes(from: Global.Type, to: Global.Symbol): Global.Type

     The applied type of class 'to' after inferring anything possible from the knowledge that 'to' must also be of the type given in 'from'.

     The applied type of class 'to' after inferring anything possible from the knowledge that 'to' must also be of the type given in 'from'.

     Definition Classes
       Checkable

189. #### def pushMacroContext(c: MacroContext): Unit

     Definition Classes
       Macros

190. #### def rebindInnerClass(pre: Global.Type, cls: Global.Symbol): Global.Type

     Attributes
       protected
     Definition Classes
       Erasure

191. #### def removeNames(typer: Typer)(args: List[Global.Tree], params: List[Global.Symbol]): (List[Global.Tree], Array[Int])

     Removes name assignments from args.

     Removes name assignments from args. Additionally, returns an array mapping argument indices from call-site-order to definition-site-order.

     Verifies that names are not specified twice, positional args don't appear after named ones.

     Definition Classes
       NamesDefaults

192. #### def reorderArgs[T](args: List[T], pos: (Int) ⇒ Int)(implicit arg0: ClassTag[T]): List[T]

     pos

       maps indices from old to new

     Definition Classes
       NamesDefaults

193. #### val requires: List[String]

     Names of phases required by this component.

     Names of phases required by this component. Default is `Nil`.

     Definition Classes
       SubComponent

194. #### def resetContexts(): Unit

     Definition Classes
       Contexts

195. #### def resetDocComments(): Unit

     Definition Classes
       Typers

196. #### def resetImplicits(): Unit

     Definition Classes
       Implicits

197. #### def resetTyper(): Unit

     Definition Classes
       Typers

198. #### final def resolveAnonymousBridgeClash(sym: Global.Symbol, bridge: Global.Symbol): Unit

     Definition Classes
       Erasure

199. #### def restrictionError(pos: Global.Position, unit: Global.CompilationUnit, msg: String): Unit

     Definition Classes
       TypeDiagnostics

200. #### def restrictionWarning(pos: Global.Position, unit: Global.CompilationUnit, msg: String): Unit

     For errors which are artifacts of the implementation: such messages indicate that the restriction may be lifted in the future.

     For errors which are artifacts of the implementation: such messages indicate that the restriction may be lifted in the future.

     Definition Classes
       TypeDiagnostics

201. #### def rootContext(unit: Global.CompilationUnit, tree: Global.Tree = EmptyTree, throwing: Boolean = false, checking: Boolean = false): Context

     Definition Classes
       Contexts

202. #### def rootContextPostTyper(unit: Global.CompilationUnit, tree: Global.Tree = EmptyTree): Context

     Definition Classes
       Contexts

203. #### def rootImports(unit: Global.CompilationUnit): List[Global.Symbol]

     List of symbols to import from in a root context.

     List of symbols to import from in a root context. Typically that is `java.lang`, `scala`, and scala.Predef, in that order. Exceptions:

     - if option `-Yno-imports` is given, nothing is imported
     - if the unit is java defined, only `java.lang` is imported
     - if option `-Yno-predef` is given, if the unit body has an import of Predef among its leading imports, or if the tree is scala.Predef, `Predef` is not imported.
     Attributes
       protected
     Definition Classes
       Contexts

204. #### val runsAfter: collection.immutable.List[String]

     Names of phases that must run before this phase.

     Names of phases that must run before this phase.

     Definition Classes
       erasure → SubComponent

205. #### val runsBefore: List[String]

     Names of phases that must run after this phase.

     Names of phases that must run after this phase. Default is `Nil`.

     Definition Classes
       SubComponent

206. #### val runsRightAfter: Some[String]

     Name of the phase that this phase must follow immediately.

     Name of the phase that this phase must follow immediately.

     Definition Classes
       erasure → SubComponent

207. #### object scalaErasure extends ScalaErasureMap

     Definition Classes
       Erasure

208. #### def setAddendum(pos: Global.Position, msg: () ⇒ String): Unit

     Definition Classes
       TypeDiagnostics

209. #### final val shortenImports: Boolean(false)

     Definition Classes
       Typers

210. #### def skipImplicit(tp: Global.Type): Global.Type

     Definition Classes
       Infer

211. #### def solvedTypes(tvars: List[Global.TypeVar], tparams: List[Global.Symbol], variances: List[Variance], upper: Boolean, depth: Depth): List[Global.Type]

     Solve constraint collected in types `tvars`.

     Solve constraint collected in types `tvars`.

     tvars

       All type variables to be instantiated.

     tparams

       The type parameters corresponding to `tvars`

     variances

       The variances of type parameters; need to reverse solution direction for all contravariant variables.

     upper

       When `true` search for max solution else min.

     Definition Classes
       Infer
     Exceptions thrown

       `NoInstance`

212. #### def specialConstructorErasure(clazz: Global.Symbol, tpe: Global.Type): Global.Type

     Definition Classes
       Erasure

213. #### def specialErasure(sym: Global.Symbol)(tp: Global.Type): Global.Type

     Definition Classes
       Erasure

214. #### object specialScalaErasure extends ScalaErasureMap

     Definition Classes
       Erasure

215. #### def standardIsBlackbox(macroDef: Global.Symbol): Boolean

     Default implementation of `isBlackbox`.

     Default implementation of `isBlackbox`. Can be overridden by analyzer plugins (see AnalyzerPlugins.pluginsIsBlackbox for more details)

     Definition Classes
       Macros

216. #### def standardMacroArgs(typer: Typer, expandee: Global.Tree): MacroArgs

     Default implementation of `macroArgs`.

     Default implementation of `macroArgs`. Can be overridden by analyzer plugins (see AnalyzerPlugins.pluginsMacroArgs for more details)

     Definition Classes
       Macros

217. #### def standardMacroExpand(typer: Typer, expandee: Global.Tree, mode: Mode, pt: Global.Type): Global.Tree

     Default implementation of `macroExpand`.

     Default implementation of `macroExpand`. Can be overridden by analyzer plugins (see AnalyzerPlugins.pluginsMacroExpand for more details)

     Definition Classes
       Macros

218. #### def standardMacroRuntime(expandee: Global.Tree): MacroRuntime

     Definition Classes
       MacroRuntimes

219. #### def standardTypedMacroBody(typer: Typer, macroDdef: Global.DefDef): Global.Tree

     Default implementation of `typedMacroBody`.

     Default implementation of `typedMacroBody`. Can be overridden by analyzer plugins (see AnalyzerPlugins.pluginsTypedMacroBody for more details)

     Definition Classes
       Macros

220. #### def superArgs(tree: Global.Tree): Option[List[List[Global.Tree]]]

     Convenience method for `SuperArgsAttachment`.

     Convenience method for `SuperArgsAttachment`. Compared with `MacroRuntimeAttachment` this attachment has different a usage pattern, so it really benefits from a dedicated extractor.

     Definition Classes
       StdAttachments

221. #### def suppressMacroExpansion(tree: Global.Tree): Global.Tree

     Suppresses macro expansion of the tree by putting SuppressMacroExpansionAttachment on it.

     Suppresses macro expansion of the tree by putting SuppressMacroExpansionAttachment on it.

     Definition Classes
       StdAttachments

222. #### final def synchronized[T0](arg0: ⇒ T0): T0

     Definition Classes
       AnyRef

223. #### val terminal: Boolean

     True if this phase runs after all other phases.

     True if this phase runs after all other phases. Usually, `terminal`.

     Definition Classes
       SubComponent

224. #### def toString(): String

     Creates a String representation of this object.

     Creates a String representation of this object. The default representation is platform dependent. On the java platform it is the concatenation of the class name, "@", and the object's hashcode in hexadecimal.

     returns

       a String representation of the object.

     Definition Classes
       AnyRef → Any

225. #### def tpe_s(tp: Global.Type, colorize: (String) ⇒ String): String

     Definition Classes
       TypersTracking

226. #### def transformInfo(sym: Global.Symbol, tp: Global.Type): Global.Type

     The symbol's erased info.

     The symbol's erased info. This is the type's erasure, except for the following symbols:

     - For $asInstanceOf : [T]T
     - For $isInstanceOf : [T]scala#Boolean
     - For class Array : [T]C where C is the erased classinfo of the Array class.
     - For Array[T].<init> : {scala#Int)Array[T]
     - For a type parameter : A type bounds type consisting of the erasures of its bounds.
     Definition Classes
       Erasure → Erasure → InfoTransform

227. #### def transformMixinInfo(tp: Global.Type): Global.Type

     Definition Classes
       AddInterfaces

228. #### def transformNamedApplication(typer: Typer, mode: Mode, pt: Global.Type)(tree: Global.Tree, argPos: (Int) ⇒ Int): Global.Tree

     Transform a function application into a Block, and assigns typer.context .namedApplyBlockInfo to the new block as side-effect.

     Transform a function application into a Block, and assigns typer.context .namedApplyBlockInfo to the new block as side-effect. If tree has the form Apply(fun, args) first the function "fun" (which might be an application itself!) is transformed into a block of the form { val qual$1 = qualifier_of_fun val x$1 = arg_1_of_fun ... val x$n = arg_n_of_fun qual$1.fun[targs](x$1, ...)...(..., x$n) } then for each argument in args, a value is created and entered into the block. finally the application expression of the block is updated. { val qual$1 = .. ... val x$n = ... > val qual$n+1 = arg(1) > ... > val qual$n+m = arg(m) > qual$1.fun[targs](x$1, ...)...(..., x$n)(x$n+1, ..., x$n+m) }

     typer

       the typer calling this method; this method calls typer.doTypedApply

     mode

       the mode to use for calling typer.doTypedApply

     pt

       the expected type for calling typer.doTypedApply

     returns

       the transformed application (a Block) together with the NamedApplyInfo. if isNamedApplyBlock(tree), returns the existing context.namedApplyBlockInfo

     Definition Classes
       NamesDefaults

229. #### def transformTypeTagEvidenceParams(macroImplRef: Global.Tree, transform: (Global.Symbol, Global.Symbol) ⇒ Global.Symbol): List[List[Global.Symbol]]

     Transforms parameters lists of a macro impl.

     Transforms parameters lists of a macro impl. The `transform` function is invoked only for WeakTypeTag evidence parameters.

     The transformer takes two arguments: a value parameter from the parameter list and a type parameter that is witnesses by the value parameter.

     If the transformer returns a NoSymbol, the value parameter is not included from the result. If the transformer returns something else, this something else is included in the result instead of the value parameter.

     Despite of being highly esoteric, this function significantly simplifies signature analysis. For example, it can be used to strip macroImpl.paramss from the evidences (necessary when checking def <-> impl correspondence) or to streamline creation of the list of macro arguments.

     Definition Classes
       Helpers

230. #### val transformed: AnyRefMap[Global.Tree, Global.Tree]

     Definition Classes
       Typers

231. #### def treeSymTypeMsg(tree: Global.Tree): String

     Definition Classes
       TypeDiagnostics

232. #### def typePatternAdvice(sym: Global.Symbol, ptSym: Global.Symbol): String

     Definition Classes
       TypeDiagnostics

233. #### def typedMacroBody(typer: Typer, macroDdef: Global.DefDef): Global.Tree

     Verifies that the body of a macro def typechecks to a reference to a static public non-overloaded method or a top-level macro bundle, and that that method is signature-wise compatible with the given macro definition.

     Verifies that the body of a macro def typechecks to a reference to a static public non-overloaded method or a top-level macro bundle, and that that method is signature-wise compatible with the given macro definition.

     returns

       Macro impl reference for the given macro definition if everything is okay. EmptyTree if an error occurs.

     Definition Classes
       Macros

234. #### object typerFactory extends SubComponent

     Definition Classes
       Analyzer

235. #### def typingInPattern[T](body: ⇒ T): T

     Devising new ways of communicating error info out of desperation to work on error messages.

     Devising new ways of communicating error info out of desperation to work on error messages. This is used by typedPattern to wrap its business so we can generate a sensible error message when things go south.

     Definition Classes
       TypeDiagnostics

236. #### object typingStack

     Definition Classes
       TypersTracking

237. #### def unapplyMember(tp: Global.Type): Global.Symbol

     Filters out unapplies with multiple (non-implicit) parameter lists, as they cannot be used as extractors

     Filters out unapplies with multiple (non-implicit) parameter lists, as they cannot be used as extractors

     Definition Classes
       Unapplies

238. #### def unboundedGenericArrayLevel(tp: Global.Type): Int

     Attributes
       protected
     Definition Classes
       Erasure

239. #### def underlyingSymbol(member: Global.Symbol): Global.Symbol

     The symbol which the given accessor represents (possibly in part).

     The symbol which the given accessor represents (possibly in part). This is used for error messages, where we want to speak in terms of the actual declaration or definition, not in terms of the generated setters and getters.

     Definition Classes
       TypeDiagnostics

240. #### def unmarkDynamicRewrite(tree: Global.Tree): Global.Tree

     Definition Classes
       StdAttachments

241. #### def unmarkMacroImplRef(tree: Global.Tree): Global.Tree

     Unmarks the tree as a macro impl reference (see `markMacroImplRef` for more information).

     Unmarks the tree as a macro impl reference (see `markMacroImplRef` for more information).

     This is necessary when a tree that was previously deemed to be a macro impl reference, typechecks to be a macro application. Then we need to unmark it, expand it and try to treat its expansion as a macro impl reference.

     Definition Classes
       StdAttachments

242. #### def unsuppressMacroExpansion(tree: Global.Tree): Global.Tree

     Unsuppresses macro expansion of the tree by removing SuppressMacroExpansionAttachment from it and its children.

     Unsuppresses macro expansion of the tree by removing SuppressMacroExpansionAttachment from it and its children.

     Definition Classes
       StdAttachments

243. #### def untypeMetalevel(tp: Global.Type): Global.Type

     Transforms c.Expr[T] types into c.Tree and leaves the rest unchanged.

     Transforms c.Expr[T] types into c.Tree and leaves the rest unchanged.

     Definition Classes
       Helpers

244. #### def valueClassIsParametric(clazz: Global.Symbol): Boolean

     Definition Classes
       Erasure

245. #### def verifyJavaErasure: Boolean

     Attributes
       protected
     Definition Classes
       Erasure → Erasure

246. #### final def wait(): Unit

     Definition Classes
       AnyRef
     Annotations
       @throws( ... )

247. #### final def wait(arg0: Long, arg1: Int): Unit

     Definition Classes
       AnyRef
     Annotations
       @throws( ... )

248. #### final def wait(arg0: Long): Unit

     Definition Classes
       AnyRef
     Annotations
       @throws( ... )

249. #### def warnUnusedImports(unit: Global.CompilationUnit): Unit

     Definition Classes
       Contexts

250. #### def withAddendum(pos: Global.Position): (String) ⇒ String

     Definition Classes
       TypeDiagnostics

251. #### def withDisambiguation[T](locals: List[Global.Symbol], types: Global.Type*)(op: ⇒ T): T

     Given any number of types, alters the name information in the symbols until they can be distinguished from one another: then executes the given code.

     Given any number of types, alters the name information in the symbols until they can be distinguished from one another: then executes the given code. The names are restored and the result is returned.

     Definition Classes
       TypeDiagnostics

### Inherited from Erasure

### Inherited from TypeAdaptingTransformer

### Inherited from TypingTransformers

### Inherited from Analyzer

### Inherited from AnalyzerPlugins

### Inherited from StdAttachments

### Inherited from ContextErrors

### Inherited from TypeDiagnostics

### Inherited from NamesDefaults

### Inherited from Macros

### Inherited from Helpers

### Inherited from Traces

### Inherited from MacroRuntimes

### Inherited from JavaReflectionRuntimes

### Inherited from Unapplies

### Inherited from SyntheticMethods

### Inherited from TreeDSL

### Inherited from EtaExpansion

### Inherited from Implicits

### Inherited from Infer

### Inherited from Checkable

### Inherited from Typers

### Inherited from PatternTypers

### Inherited from TypersTracking

### Inherited from Tags

### Inherited from Adaptations

### Inherited from Namers

### Inherited from MethodSynthesis

### Inherited from Contexts

### Inherited from Erasure

### Inherited from AddInterfaces

### Inherited from InfoTransform

### Inherited from Transform

### Inherited from SubComponent

### Inherited from AnyRef

### Inherited from Any

### Ungrouped