Object

scala.tools.nsc.Global

erasure

Related Doc: package Global

Permalink

object erasure extends Erasure

Definition Classes
Global → Transforms
Source
Global.scala
Linear Supertypes
Content Hierarchy
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
Visibility
  1. Public
  2. All

Type Members

  1. abstract class AbsAmbiguousTypeError extends Analyzer.AbsTypeError

    Permalink
    Definition Classes
    ContextErrors
  2. sealed abstract class AbsTypeError extends Throwable

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

    Permalink
    Definition Classes
    ContextErrors
  4. trait Adaptation extends AnyRef

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

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

    Permalink
    Definition Classes
    ContextErrors
  7. trait AnalyzerPlugin extends AnyRef

    Permalink
    Definition Classes
    AnalyzerPlugins
  8. class ClassForCaseCompanionAttachment extends AnyRef

    Permalink
    Definition Classes
    Unapplies
  9. class ClassMethodSynthesis extends AnyRef

    Permalink
    Definition Classes
    MethodSynthesis
  10. class ComputeBridges extends AnyRef

    Permalink
    Definition Classes
    Erasure
  11. class ConstructorDefaultsAttachment extends AnyRef

    Permalink
    Definition Classes
    NamesDefaults
  12. class Context extends AnyRef

    Permalink

    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 Inferencer#isApplicableSafe type checks applications with and without an expected type, or when Typer#tryTypedApply tries to fit arguments to a function type with/without implicit views.

    When the error policies entail 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 a separate, fresh buffer.

    Definition Classes
    Contexts
  13. abstract class ContextReporter extends Reporter

    Permalink

    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

    Permalink

    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

    Permalink
    Definition Classes
    NamesDefaults
  16. case class Delayed(delayed: Global.Tree) extends Analyzer.MacroStatus with Product with Serializable

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

    Permalink
    Definition Classes
    ContextErrors
  18. class Eraser extends Typer with TypeAdapter

    Permalink

    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

    Permalink
    Definition Classes
    Erasure
  20. class ErasureTransformer extends Global.Transformer

    Permalink

    The erasure transformer

    The erasure transformer

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

    Permalink
    Definition Classes
    Macros
  22. case class Fallback(fallback: Global.Tree) extends Analyzer.MacroStatus with Product with Serializable

    Permalink
    Definition Classes
    Macros
  23. class ImplicitInfo extends AnyRef

    Permalink

    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

    Permalink

    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

    Permalink
    Definition Classes
    ContextErrors
  26. trait ImportContext extends Analyzer.Context

    Permalink

    A Context focussed on an Import tree

    A Context focussed on an Import tree

    Definition Classes
    Contexts
  27. class ImportInfo extends AnyRef

    Permalink
    Definition Classes
    Contexts
  28. type ImportType = Global.ImportType

    Permalink
    Definition Classes
    Contexts
  29. trait InferCheckable extends AnyRef

    Permalink
    Definition Classes
    Checkable
  30. abstract class Inferencer extends Analyzer.InferencerContextErrors with Analyzer.InferCheckable

    Permalink

    The context-dependent inferencer part

    The context-dependent inferencer part

    Definition Classes
    Infer
  31. trait InferencerContextErrors extends AnyRef

    Permalink
    Definition Classes
    ContextErrors
  32. class JavaErasureMap extends ErasureMap

    Permalink
    Definition Classes
    Erasure
  33. trait JavaReflectionResolvers extends AnyRef

    Permalink
    Definition Classes
    JavaReflectionRuntimes
  34. trait LockingTypeCompleter extends Analyzer.TypeCompleter

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

    Permalink

    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 }

    Permalink
    Definition Classes
    StdAttachments
  37. abstract class MacroExpander extends AnyRef

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink

    Definition Classes
    AnalyzerPlugins
  42. type MacroRuntime = (MacroArgs) ⇒ Any

    Permalink

    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

    Permalink
    Definition Classes
    StdAttachments
  44. class MacroRuntimeResolver extends tools.nsc.typechecker.Analyzer.JavaReflectionResolvers

    Permalink
    Definition Classes
    MacroRuntimes
  45. sealed abstract class MacroStatus extends AnyRef

    Permalink
    Definition Classes
    Macros
  46. trait MethodSynth extends AnyRef

    Permalink

    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

    Permalink
    Definition Classes
    NamesDefaults
  48. abstract class Namer extends Analyzer.MethodSynth with Analyzer.NamerContextErrors

    Permalink
    Definition Classes
    Namers
  49. trait NamerContextErrors extends AnyRef

    Permalink
    Definition Classes
    ContextErrors
  50. class NoInstance extends Throwable with ControlThrowable

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

    Permalink
    Definition Classes
    ContextErrors
  52. class NormalTypeErrorFromCyclicReference extends Analyzer.NormalTypeError

    Permalink

    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

    Permalink

    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

    Permalink
    Definition Classes
    PatternTypers
  55. class Phase extends InfoTransform.Phase

    Permalink
    Definition Classes
    InfoTransform
  56. class PolyTypeCompleter extends Analyzer.TypeCompleter with Analyzer.LockingTypeCompleter with Global.FlagAgnosticCompleter

    Permalink

    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

    Permalink
    Definition Classes
    ContextErrors
  58. class ScalaErasureMap extends ErasureMap

    Permalink
    Definition Classes
    Erasure
  59. class SearchResult extends AnyRef

    Permalink

    The result of an implicit search

    The result of an implicit search

    Definition Classes
    Implicits
  60. sealed abstract class SilentResult[+T] extends AnyRef

    Permalink
    Definition Classes
    Typers
  61. case class SilentResultValue[+T](value: T) extends Analyzer.SilentResult[T] with Product with Serializable

    Permalink
    Definition Classes
    Typers
  62. class SilentTypeError extends Analyzer.SilentResult[Nothing]

    Permalink
    Definition Classes
    Typers
  63. case class Skipped(skipped: Global.Tree) extends Analyzer.MacroStatus with Product with Serializable

    Permalink
    Definition Classes
    Macros
  64. abstract class StdPhase extends GlobalPhase

    Permalink

    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

    Permalink
    Definition Classes
    Macros
  66. case class SuperArgsAttachment(argss: List[List[Global.Tree]]) extends Product with Serializable

    Permalink

    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

    Permalink
    Definition Classes
    ContextErrors
  68. trait Tag extends AnyRef

    Permalink
    Definition Classes
    Tags
  69. sealed abstract class TreeTypeError extends Analyzer.AbsTypeError

    Permalink
    Definition Classes
    ContextErrors
  70. trait TypeAdapter extends AnyRef

    Permalink
    Definition Classes
    TypeAdaptingTransformer
  71. abstract class TypeCompleter extends Global.LazyType

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

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

    Permalink
    Definition Classes
    ContextErrors
  74. case class TypeErrorWrapper(ex: Global.TypeError) extends Analyzer.AbsTypeError with Product with Serializable

    Permalink
    Definition Classes
    ContextErrors
  75. abstract class Typer extends Analyzer.TyperDiagnostics with Analyzer.Adaptation with Analyzer.Tag with Analyzer.PatternTyper with Analyzer.TyperContextErrors

    Permalink
    Definition Classes
    Typers
  76. trait TyperContextErrors extends AnyRef

    Permalink
    Definition Classes
    ContextErrors
  77. trait TyperDiagnostics extends AnyRef

    Permalink
    Definition Classes
    TypeDiagnostics
  78. abstract class TypingTransformer extends Global.Transformer

    Permalink
    Definition Classes
    TypingTransformers
  79. type UnaffiliatedMacroContext = reflect.macros.contexts.Context

    Permalink

    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

    Permalink
    Definition Classes
    Erasure

Value Members

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

    Permalink

    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

    Permalink

    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

    Permalink

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

    returns

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

    Definition Classes
    AnyRef → Any
  4. lazy val AmbiguousSearchFailure: SearchResult

    Permalink
    Definition Classes
    Implicits
  5. object CODE

    Permalink
    Definition Classes
    TreeDSL
  6. def Delay(expanded: Global.Tree): Delayed

    Permalink
    Definition Classes
    Macros
  7. lazy val DivergentSearchFailure: SearchResult

    Permalink
    Definition Classes
    Implicits
  8. object DynamicRewriteAttachment extends Product with Serializable

    Permalink

    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

    Permalink
    Definition Classes
    ContextErrors
  10. object Function1

    Permalink

    An extractor for unary function types arg => res

    An extractor for unary function types arg => res

    Definition Classes
    Implicits
  11. object GenericArray

    Permalink
    Definition Classes
    Erasure
  12. object HasMember

    Permalink

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

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

    Definition Classes
    Implicits
  13. object HasMethodMatching

    Permalink

    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

    Permalink
    Definition Classes
    Unapplies
  15. object ImplicitNotFoundMsg

    Permalink
    Definition Classes
    Implicits
  16. val ImportType: Global.ImportType.type

    Permalink
    Definition Classes
    Contexts
  17. def MacroCantExpand210xMacrosError(internalMessage: String): Nothing

    Permalink
    Definition Classes
    ContextErrors
  18. def MacroCantExpandIncompatibleMacrosError(internalMessage: String): Nothing

    Permalink
    Definition Classes
    ContextErrors
  19. object MacroImplBinding extends Serializable

    Permalink
    Definition Classes
    Macros
  20. object MacroImplRefAttachment extends Product with Serializable

    Permalink

    Definition Classes
    StdAttachments
    See also

    markMacroImplRef

  21. object NamesDefaultsErrorsGen

    Permalink
    Definition Classes
    ContextErrors
  22. object NoContext extends Analyzer.Context

    Permalink
    Definition Classes
    Contexts
  23. def NoImplicitFoundError(tree: Global.Tree, param: Global.Symbol)(implicit context: Context): Unit

    Permalink
    Definition Classes
    ContextErrors
  24. val NoImplicitInfo: ImplicitInfo

    Permalink

    A sentinel indicating no implicit was found

    A sentinel indicating no implicit was found

    Definition Classes
    Implicits
  25. lazy val SearchFailure: SearchResult

    Permalink
    Definition Classes
    Implicits
  26. object SilentTypeError

    Permalink
    Definition Classes
    Typers
  27. def Skip(expanded: Global.Tree): Skipped

    Permalink
    Definition Classes
    Macros
  28. object SuppressMacroExpansionAttachment extends Product with Serializable

    Permalink

    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

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

    Permalink

    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

    Permalink

    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

    Permalink

    Definition Classes
    AnalyzerPlugins
    See also

    AnalyzerPlugin.adaptAnnotations

  33. def addAnalyzerPlugin(plugin: AnalyzerPlugin): Unit

    Permalink

    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])

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink
    Definition Classes
    SubComponent
    Annotations
    @inline()
  38. def allArgsArePositional(a: Array[Int]): Boolean

    Permalink

    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])]

    Permalink

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

    tp

    from-type for the implicit conversion

    context

    search implicits here

    tpars

    symbols that should be considered free type variables (implicit search should not try to solve them, just track their constraints)

    Definition Classes
    Implicits
  40. def alternatives(tree: Global.Tree): List[Global.Type]

    Permalink
    Definition Classes
    TypeDiagnostics
  41. def alternativesString(tree: Global.Tree): String

    Permalink
    Definition Classes
    TypeDiagnostics
  42. def ambiguousDefnAndImport(owner: Global.Symbol, imp: ImportInfo): Global.LookupAmbiguous

    Permalink
    Definition Classes
    Contexts
  43. def ambiguousImports(imp1: ImportInfo, imp2: ImportInfo): Global.LookupAmbiguous

    Permalink
    Definition Classes
    Contexts
  44. val analyzer: Analyzer { val global: scala.tools.nsc.Global.erasure.global.type }

    Permalink
    Definition Classes
    ErasureTypeAdaptingTransformer
  45. final def asInstanceOf[T0]: T0

    Permalink

    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

    Permalink
    Definition Classes
    SubComponent
    Annotations
    @inline()
  47. def bindMacroImpl(macroDef: Global.Symbol, macroImplRef: Global.Tree): Unit

    Permalink
    Definition Classes
    Macros
  48. def canAdaptAnnotations(tree: Global.Tree, typer: Typer, mode: Mode, pt: Global.Type): Boolean

    Permalink

    Definition Classes
    AnalyzerPlugins
    See also

    AnalyzerPlugin.canAdaptAnnotations

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

    Permalink

    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]

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink

    The unapply method corresponding to a case class

    The unapply method corresponding to a case class

    Definition Classes
    Unapplies
  54. def changesBaseClasses: Boolean

    Permalink
    Attributes
    protected
    Definition Classes
    InfoTransform
  55. final def clearRenamedCaseAccessors(caseclazz: Global.Symbol): Unit

    Permalink
    Definition Classes
    SyntheticMethods
  56. def clone(): AnyRef

    Permalink

    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

    Permalink
    Definition Classes
    Unapplies
  58. def companionSymbolOf(original: Global.Symbol, ctx: Context): Global.Symbol

    Permalink

    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

    Permalink
    Definition Classes
    Macros
  60. def decodeWithKind(name: Global.Name, owner: Global.Symbol): String

    Permalink
    Definition Classes
    TypeDiagnostics
  61. val deconstMap: Global.TypeMap

    Permalink
    Definition Classes
    Erasure
  62. def decreaseMetalevel(tp: Global.Type): Global.Type

    Permalink

    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

    Permalink

    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

    Permalink

    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]

    Permalink

    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

    Permalink

    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]

    Permalink
    Definition Classes
    TypeDiagnostics
  68. def enabled: Boolean

    Permalink

    Is this component enabled? Default is true.

    Is this component enabled? Default is true.

    Definition Classes
    SubComponent
  69. def enclosingMacroPosition: reflect.internal.util.Position

    Permalink
    Definition Classes
    Macros
  70. final def eq(arg0: AnyRef): Boolean

    Permalink

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

    Tests whether the argument (that) 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

    Permalink

    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

    Permalink
    Definition Classes
    Erasure
  73. def erasure(sym: Global.Symbol): ErasureMap

    Permalink
    Definition Classes
    Erasure
  74. def etaExpand(unit: Global.CompilationUnit, tree: Global.Tree, typer: Typer): Global.Tree

    Permalink

    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

    Permalink
    Definition Classes
    EtaExpansion
  76. final def exampleTuplePattern(names: List[Global.Name]): String

    Permalink

    [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

    Permalink
    Definition Classes
    TypeDiagnostics
  78. def explainAlias(tp: Global.Type): String

    Permalink
    Definition Classes
    TypeDiagnostics
  79. def explainAnyVsAnyRef(found: Global.Type, req: Global.Type): String

    Permalink
    Definition Classes
    TypeDiagnostics
  80. def explainVariance(found: Global.Type, req: Global.Type): String

    Permalink

    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

    Permalink

    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

    Permalink
    Definition Classes
    Infer
    Annotations
    @inline()
  83. lazy val fastTrack: FastTrack[Global.erasure.this.type]

    Permalink
    Definition Classes
    Macros
  84. def finalize(): Unit

    Permalink

    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

    Permalink

    Obtains a ClassLoader instance used for macro expansion.

    Obtains a ClassLoader instance used for macro expansion.

    By default a new ScalaClassLoader is created using the classpath from global and the classloader of self as parent.

    Mirrors with runtime definitions (e.g. Repl) need to adjust this method.

    Attributes
    protected
    Definition Classes
    Macros
  86. final def forArgMode(fun: Global.Tree, mode: Mode): reflect.internal.Mode

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

    Permalink

    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

    Permalink
    Definition Classes
    TypeDiagnostics
  89. def freshVar(tparam: Global.Symbol): Global.TypeVar

    Permalink

    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

    Permalink
    Definition Classes
    TypersTracking
  91. final def getClass(): Class[_]

    Permalink

    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

    Permalink

    The global environment; overridden by instantiation in Global.

    The global environment; overridden by instantiation in Global.

    Definition Classes
    erasureTypingTransformersAnalyzerTreeDSL → Erasure → SubComponent
  93. def globalSettings: Settings

    Permalink
    Definition Classes
    MacrosTraces
  94. def hasMacroExpansionAttachment(any: Any): Boolean

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink

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

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

    Definition Classes
    AddInterfaces
  99. def implClassDefs(trees: List[Global.Tree]): List[Global.Tree]

    Permalink
    Definition Classes
    AddInterfaces
  100. def implClassPhase: reflect.internal.Phase

    Permalink
    Definition Classes
    AddInterfaces
  101. def increaseMetalevel(pre: Global.Type, tp: Global.Type): Global.Type

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink
    Definition Classes
    Implicits
  105. def inferImplicit(tree: Global.Tree, pt: Global.Type, reportAmbiguous: Boolean, isView: Boolean, context: Context): SearchResult

    Permalink
    Definition Classes
    Implicits
  106. val initial: Boolean

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink
    Definition Classes
    Erasure
  110. def isBlackbox(macroDef: Global.Symbol): Boolean

    Permalink
    Definition Classes
    Macros
  111. def isBlackbox(expandee: Global.Tree): Boolean

    Permalink
    Definition Classes
    Macros
  112. def isDynamicRewrite(tree: Global.Tree): Boolean

    Permalink
    Definition Classes
    StdAttachments
  113. final def isInstanceOf[T0]: Boolean

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink
    Definition Classes
    NamesDefaults
  117. def javaSig(sym0: Global.Symbol, info: Global.Type): Option[String]

    Permalink

    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

    Permalink
    Definition Classes
    ErasureInfoTransform
  119. var lastAccessCheckDetails: String

    Permalink
    Definition Classes
    Contexts
  120. var lastTreeToTyper: Global.Tree

    Permalink
    Definition Classes
    TypersTracking
  121. def linePrecedes(t1: Global.Tree, t2: Global.Tree): Boolean

    Permalink
    Definition Classes
    TypeDiagnostics
  122. def linkExpandeeAndDesugared(expandee: Global.Tree, desugared: Global.Tree): Unit

    Permalink

    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

    Permalink

    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

    Permalink

    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]

    Permalink
    Definition Classes
    Macros
  126. def lockedCount: Int

    Permalink
    Definition Classes
    Namers
  127. def macroArgs(typer: Typer, expandee: Global.Tree): MacroArgs

    Permalink
    Definition Classes
    Macros
  128. def macroContext(typer: Typer, prefixTree: Global.Tree, expandeeTree: Global.Tree): MacroContext

    Permalink
    Definition Classes
    Macros
  129. val macroDebugLite: Boolean

    Permalink
    Definition Classes
    Traces
  130. val macroDebugVerbose: Boolean

    Permalink
    Definition Classes
    Traces
  131. def macroEngine: String

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink
    Definition Classes
    Traces
    Annotations
    @inline()
  139. final def macroLogVerbose(msg: ⇒ Any): Unit

    Permalink
    Definition Classes
    Traces
    Annotations
    @inline()
  140. def macroRuntime(expandee: Global.Tree): MacroRuntime

    Permalink

    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]

    Permalink
    Definition Classes
    NamesDefaults
  142. def markDynamicRewrite(tree: Global.Tree): Global.Tree

    Permalink
    Definition Classes
    StdAttachments
  143. def markMacroImplRef(tree: Global.Tree): Global.Tree

    Permalink

    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

    Permalink

    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]

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

    Permalink

    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

    Permalink
    Attributes
    protected
    Definition Classes
    AddInterfaces
  148. def mkTypeCompleter(t: Global.Tree)(c: (Global.Symbol) ⇒ Unit): TypeCompleter with LockingTypeCompleter with Global.FlagAgnosticCompleter

    Permalink
    Definition Classes
    Namers
  149. object namerFactory extends SubComponent

    Permalink
    Definition Classes
    Analyzer
  150. final def ne(arg0: AnyRef): Boolean

    Permalink

    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 needsImplMethod(sym: Global.Symbol): Boolean

    Permalink

    Does symbol need an implementation method?

    Does symbol need an implementation method?

    Definition Classes
    AddInterfaces
  152. def needsJavaSig(tp: Global.Type): Boolean

    Permalink
    Definition Classes
    Erasure
  153. def newNamer(context: Context): Namer

    Permalink
    Definition Classes
    Namers
  154. def newPhase(prev: nsc.Phase): StdPhase

    Permalink

    Create a new phase which applies transformer

    Create a new phase which applies transformer

    Definition Classes
    AddInterfacesInfoTransformTransformSubComponent
  155. def newTransformer(unit: Global.CompilationUnit): Global.Transformer

    Permalink

    The transformer factory

    The transformer factory

    Definition Classes
    ErasureTransform
  156. def newTyper(context: Context): Eraser

    Permalink
    Definition Classes
    ErasureTypers
  157. def noPrintAdapt(tree1: Global.Tree, tree2: Global.Tree): Boolean

    Permalink
    Definition Classes
    TypersTracking
  158. def noPrintTyping(t: Global.Tree): Boolean

    Permalink
    Definition Classes
    TypersTracking
  159. def normalize(tp: Global.Type): Global.Type

    Permalink

    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
  160. def notAnyRefMessage(found: Global.Type): String

    Permalink
    Definition Classes
    ContextErrors
  161. final def notify(): Unit

    Permalink

    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

  162. final def notifyAll(): Unit

    Permalink

    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

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

    Permalink
    Definition Classes
    Macros
  164. def notifyUndetparamsInferred(undetNoMore: List[Global.Symbol], inferreds: List[Global.Type]): Unit

    Permalink
    Definition Classes
    Macros
  165. def numericConversion(tree: Global.Tree, numericSym: Global.Symbol): Global.Tree

    Permalink
    Definition Classes
    Erasure
  166. def onTreeCheckerError(pos: Global.Position, msg: String): Unit

    Permalink
    Attributes
    protected
    Definition Classes
    Contexts
  167. def openMacros: collection.immutable.List[reflect.macros.contexts.Context { val universe: scala.tools.nsc.Global.erasure.global.type }]

    Permalink
    Definition Classes
    Macros
  168. def ownPhase: nsc.Phase

    Permalink

    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
  169. object packageObjects extends SubComponent

    Permalink
    Definition Classes
    Analyzer
  170. val phaseName: String

    Permalink

    The name of the phase

    The name of the phase

    Definition Classes
    ErasureSubComponent
  171. def phaseNewFlags: Long

    Permalink

    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
    AddInterfacesSubComponent
  172. def phaseNextFlags: Long

    Permalink

    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
  173. def pluginsEnsureCompanionObject(namer: Namer, cdef: Global.ClassDef, creator: (Global.ClassDef) ⇒ Global.Tree = companionModuleDef(_)): Global.Symbol

    Permalink

    Definition Classes
    AnalyzerPlugins
    See also

    MacroPlugin.pluginsEnsureCompanionObject

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

    Permalink

    Definition Classes
    AnalyzerPlugins
    See also

    MacroPlugin.pluginsEnterStats

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

    Permalink

    Definition Classes
    AnalyzerPlugins
    See also

    MacroPlugin.pluginsEnterSym

  176. def pluginsIsBlackbox(macroDef: Global.Symbol): Boolean

    Permalink

    Definition Classes
    AnalyzerPlugins
    See also

    MacroPlugin.pluginsIsBlackbox

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

    Permalink

    Definition Classes
    AnalyzerPlugins
    See also

    MacroPlugin.pluginsMacroArgs

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

    Permalink

    Definition Classes
    AnalyzerPlugins
    See also

    MacroPlugin.pluginsMacroExpand

  179. def pluginsMacroRuntime(expandee: Global.Tree): MacroRuntime

    Permalink

    Definition Classes
    AnalyzerPlugins
    See also

    MacroPlugin.pluginsMacroRuntime

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

    Permalink

    Definition Classes
    AnalyzerPlugins
    See also

    AnalyzerPlugin.pluginsPt

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

    Permalink

    Definition Classes
    AnalyzerPlugins
    See also

    AnalyzerPlugin.pluginsTypeSig

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

    Permalink

    Definition Classes
    AnalyzerPlugins
    See also

    AnalyzerPlugin.pluginsTypeSigAccessor

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

    Permalink

    Definition Classes
    AnalyzerPlugins
    See also

    AnalyzerPlugin.pluginsTyped

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

    Permalink

    Definition Classes
    AnalyzerPlugins
    See also

    MacroPlugin.pluginsTypedMacroBody

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

    Permalink

    Definition Classes
    AnalyzerPlugins
    See also

    AnalyzerPlugin.pluginsTypedReturn

  186. def popMacroContext(): Unit

    Permalink
    Definition Classes
    Macros
  187. def posPrecedes(p1: Global.Position, p2: Global.Position): Boolean

    Permalink

    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
  188. val prepareSigMap: Global.TypeMap { def squashBoxed(tp: scala.tools.nsc.Global.erasure.global.Type): scala.tools.nsc.Global.erasure.global.Type }

    Permalink

    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
  189. def printingOk(t: Global.Tree): Boolean

    Permalink
    Definition Classes
    TypersTracking
  190. def propagateKnownTypes(from: Global.Type, to: Global.Symbol): Global.Type

    Permalink

    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
  191. def pushMacroContext(c: MacroContext): Unit

    Permalink
    Definition Classes
    Macros
  192. def rebindInnerClass(pre: Global.Type, cls: Global.Symbol): Global.Type

    Permalink
    Attributes
    protected
    Definition Classes
    Erasure
  193. def removeNames(typer: Typer)(args: List[Global.Tree], params: List[Global.Symbol]): (List[Global.Tree], Array[Int])

    Permalink

    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
  194. def reorderArgs[T](args: List[T], pos: (Int) ⇒ Int)(implicit arg0: ClassTag[T]): List[T]

    Permalink

    pos

    maps indices from old to new

    Definition Classes
    NamesDefaults
  195. val requires: List[String]

    Permalink

    Names of phases required by this component.

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

    Definition Classes
    SubComponent
  196. def resetContexts(): Unit

    Permalink
    Definition Classes
    Contexts
  197. def resetDocComments(): Unit

    Permalink
    Definition Classes
    Typers
  198. def resetImplicits(): Unit

    Permalink
    Definition Classes
    Implicits
  199. def resetTyper(): Unit

    Permalink
    Definition Classes
    Typers
  200. final def resolveAnonymousBridgeClash(sym: Global.Symbol, bridge: Global.Symbol): Unit

    Permalink
    Definition Classes
    Erasure
  201. def restrictionError(pos: Global.Position, unit: Global.CompilationUnit, msg: String): Unit

    Permalink
    Definition Classes
    TypeDiagnostics
  202. def restrictionWarning(pos: Global.Position, unit: Global.CompilationUnit, msg: String): Unit

    Permalink

    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
  203. def rootContext(unit: Global.CompilationUnit, tree: Global.Tree = EmptyTree, throwing: Boolean = false, checking: Boolean = false): Context

    Permalink
    Definition Classes
    Contexts
  204. def rootContextPostTyper(unit: Global.CompilationUnit, tree: Global.Tree = EmptyTree): Context

    Permalink
    Definition Classes
    Contexts
  205. def rootImports(unit: Global.CompilationUnit): List[Global.Symbol]

    Permalink

    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
  206. val runsAfter: collection.immutable.List[String]

    Permalink

    Names of phases that must run before this phase.

    Names of phases that must run before this phase.

    Definition Classes
    erasureSubComponent
  207. val runsBefore: List[String]

    Permalink

    Names of phases that must run after this phase.

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

    Definition Classes
    SubComponent
  208. val runsRightAfter: Some[String]

    Permalink

    Name of the phase that this phase must follow immediately.

    Name of the phase that this phase must follow immediately.

    Definition Classes
    erasureSubComponent
  209. object scalaErasure extends ScalaErasureMap

    Permalink
    Definition Classes
    Erasure
  210. def setAddendum(pos: Global.Position, msg: () ⇒ String): Unit

    Permalink
    Definition Classes
    TypeDiagnostics
  211. final val shortenImports: Boolean(false)

    Permalink
    Definition Classes
    Typers
  212. def skipImplicit(tp: Global.Type): Global.Type

    Permalink
    Definition Classes
    Infer
  213. def solvedTypes(tvars: List[Global.TypeVar], tparams: List[Global.Symbol], variances: List[Variance], upper: Boolean, depth: Depth): List[Global.Type]

    Permalink

    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
  214. def specialConstructorErasure(clazz: Global.Symbol, tpe: Global.Type): Global.Type

    Permalink
    Definition Classes
    Erasure
  215. def specialErasure(sym: Global.Symbol)(tp: Global.Type): Global.Type

    Permalink
    Definition Classes
    Erasure
  216. object specialScalaErasure extends ScalaErasureMap

    Permalink
    Definition Classes
    Erasure
  217. def standardIsBlackbox(macroDef: Global.Symbol): Boolean

    Permalink

    Default implementation of isBlackbox.

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

    Definition Classes
    Macros
  218. def standardMacroArgs(typer: Typer, expandee: Global.Tree): MacroArgs

    Permalink

    Default implementation of macroArgs.

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

    Definition Classes
    Macros
  219. def standardMacroExpand(typer: Typer, expandee: Global.Tree, mode: Mode, pt: Global.Type): Global.Tree

    Permalink

    Default implementation of macroExpand.

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

    Definition Classes
    Macros
  220. def standardMacroRuntime(expandee: Global.Tree): MacroRuntime

    Permalink
    Definition Classes
    MacroRuntimes
  221. def standardTypedMacroBody(typer: Typer, macroDdef: Global.DefDef): Global.Tree

    Permalink

    Default implementation of typedMacroBody.

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

    Definition Classes
    Macros
  222. def superArgs(tree: Global.Tree): Option[List[List[Global.Tree]]]

    Permalink

    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
  223. def suppressMacroExpansion(tree: Global.Tree): Global.Tree

    Permalink

    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
  224. final def synchronized[T0](arg0: ⇒ T0): T0

    Permalink
    Definition Classes
    AnyRef
  225. val terminal: Boolean

    Permalink

    True if this phase runs after all other phases.

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

    Definition Classes
    SubComponent
  226. def toString(): String

    Permalink

    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
  227. def tpe_s(tp: Global.Type, colorize: (String) ⇒ String): String

    Permalink
    Definition Classes
    TypersTracking
  228. def transformInfo(sym: Global.Symbol, tp: Global.Type): Global.Type

    Permalink

    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
  229. def transformMixinInfo(tp: Global.Type): Global.Type

    Permalink
    Definition Classes
    AddInterfaces
  230. def transformNamedApplication(typer: Typer, mode: Mode, pt: Global.Type)(tree: Global.Tree, argPos: (Int) ⇒ Int): Global.Tree

    Permalink

    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
  231. def transformTypeTagEvidenceParams(macroImplRef: Global.Tree, transform: (Global.Symbol, Global.Symbol) ⇒ Global.Symbol): List[List[Global.Symbol]]

    Permalink

    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
  232. val transformed: AnyRefMap[Global.Tree, Global.Tree]

    Permalink
    Definition Classes
    Typers
  233. def treeSymTypeMsg(tree: Global.Tree): String

    Permalink
    Definition Classes
    TypeDiagnostics
  234. def typePatternAdvice(sym: Global.Symbol, ptSym: Global.Symbol): String

    Permalink
    Definition Classes
    TypeDiagnostics
  235. def typedMacroBody(typer: Typer, macroDdef: Global.DefDef): Global.Tree

    Permalink

    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
  236. object typerFactory extends SubComponent

    Permalink
    Definition Classes
    Analyzer
  237. def typingInPattern[T](body: ⇒ T): T

    Permalink

    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
  238. object typingStack

    Permalink
    Definition Classes
    TypersTracking
  239. def unapplyMember(tp: Global.Type): Global.Symbol

    Permalink

    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
  240. def unboundedGenericArrayLevel(tp: Global.Type): Int

    Permalink
    Attributes
    protected
    Definition Classes
    Erasure
  241. def underlyingSymbol(member: Global.Symbol): Global.Symbol

    Permalink

    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
  242. def unmarkDynamicRewrite(tree: Global.Tree): Global.Tree

    Permalink
    Definition Classes
    StdAttachments
  243. def unmarkMacroImplRef(tree: Global.Tree): Global.Tree

    Permalink

    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
  244. def unsuppressMacroExpansion(tree: Global.Tree): Global.Tree

    Permalink

    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
  245. def untypeMetalevel(tp: Global.Type): Global.Type

    Permalink

    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
  246. def valueClassIsParametric(clazz: Global.Symbol): Boolean

    Permalink
    Definition Classes
    Erasure
  247. def verifyJavaErasure: Boolean

    Permalink
    Attributes
    protected
    Definition Classes
    Erasure → Erasure
  248. final def wait(): Unit

    Permalink
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  249. final def wait(arg0: Long, arg1: Int): Unit

    Permalink
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  250. final def wait(arg0: Long): Unit

    Permalink
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  251. def warnUnusedImports(unit: Global.CompilationUnit): Unit

    Permalink
    Definition Classes
    Contexts
  252. def withAddendum(pos: Global.Position): (String) ⇒ String

    Permalink
    Definition Classes
    TypeDiagnostics
  253. def withDisambiguation[T](locals: List[Global.Symbol], types: Global.Type*)(op: ⇒ T): T

    Permalink

    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