Scala Compiler 2.13.16 - scala.tools.nsc.Global.treeChecker
Keywords: Scala Compiler 2.13.16 scala.tools.nsc.Global.treeChecker

Scala Compiler2.13.16 < Back


# Packages

-  package root

  The Scala compiler and reflection APIs.

  The Scala compiler and reflection APIs.

  Definition Classes
    root
-  package scala
  Definition Classes
    root
-  package tools
  Definition Classes
    scala
-  package nsc
  Definition Classes
    tools
-  class Global extends SymbolTable with Closeable with CompilationUnits with Plugins with PhaseAssembly with Trees with Printers with DocComments with Positions with Reporting with Parsing
  Definition Classes
    nsc
- AbstractTypeRef
- AbstractTypeSymbol
- AliasTypeRef
- AliasTypeSymbol
- Alternative
- Alternative
- AlternativeApi
- AlternativeExtractor
- Annotatable
- Annotated
- Annotated
- AnnotatedApi
- AnnotatedExtractor
- AnnotatedType
- AnnotatedType
- AnnotatedTypeApi
- AnnotatedTypeExtractor
- AnnotationApi
- AnnotationChecker
- AnnotationExtractor
- AnnotationFilter
- AnnotationInfo
- AnnotationInfo
- AntiPolyType
- AppliedTypeTree
- AppliedTypeTree
- AppliedTypeTreeApi
- AppliedTypeTreeExtractor
- AppliedTypeVar
- Apply
- Apply
- ApplyApi
- ApplyDynamic
- ApplyExtractor
- ApplyImplicitView
- ApplyToImplicitArgs
- ApproximateDependentMap
- ArgsTypeRef
- ArrayAnnotArg
- ArrayValue
- AsSeenFromMap
- Assign
- Assign
- AssignApi
- AssignExtractor
- Attachable
- AutoApplicationAttachment
- BackquotedIdentifierAttachment
- BaseTypeSeq
- Bind
- Bind
- BindApi
- BindExtractor
- Block
- Block
- BlockApi
- BlockExtractor
- BooleanFlag
- BooleanFlag
- BooleanParameterType
- BoundedWildcardType
- BoundedWildcardType
- BoundedWildcardTypeApi
- BoundedWildcardTypeExtractor
- CannotHaveAttrs
- CaseApplyInheritAccess
- CaseDef
- CaseDef
- CaseDefApi
- CaseDefExtractor
- ChangeOwnerAttachment
- ChangeOwnerTraverser
- ChildSolidDescendantsCollector
- ClassDef
- ClassDef
- ClassDefApi
- ClassDefExtractor
- ClassInfoType
- ClassInfoType
- ClassInfoTypeApi
- ClassInfoTypeExtractor
- ClassMirror
- ClassSymbol
- ClassSymbolApi
- ClassUnwrapper
- ClassfileAnnotArg
- CodePrinter
- CollectTreeTraverser
- CollectTypeCollector
- CommonNames
- CommonOwnerMap
- CompactTreePrinter
- CompatApi
- CompatToken
- CompilationUnit
- CompilationUnitContextApi
- CompleteAnnotationInfo
- CompoundType
- CompoundType
- CompoundTypeApi
- CompoundTypeTree
- CompoundTypeTree
- CompoundTypeTreeApi
- CompoundTypeTreeExtractor
- CompoundTypeTreeOriginalAttachment
- ConsoleWriter
- Constant
- Constant
- ConstantApi
- ConstantExtractor
- ConstantType
- ConstantType
- ConstantTypeApi
- ConstantTypeExtractor
- ConstructorNeedsFence
- ContainsAnyKeyCollector
- ContainsCollector
- CyclicReference
- CyclicReference
- DefDef
- DefDef
- DefDefApi
- DefDefExtractor
- DefTree
- DefTreeApi
- DefaultPosAssigner
- DefinitionsApi
- DefinitionsClass
- DelambdafyTarget
- DiscardedExpr
- DiscardedValue
- DocComment
- DocDef
- DottyEnumSingleton
- DottyOpaqueTypeAlias
- DottyParameterisedTrait
- EmptyScope
- EmptyTree
- ErasedValueType
- ErasedValueType
- ErroneousAnnotation
- ErrorScope
- ErrorType
- ExistentialExtrapolation
- ExistentialType
- ExistentialType
- ExistentialTypeApi
- ExistentialTypeExtractor
- ExistentialTypeTree
- ExistentialTypeTree
- ExistentialTypeTreeApi
- ExistentialTypeTreeExtractor
- ExistsTypeRefCollector
- ExpansionLimitExceeded
- Expr
- Expr
- ExtraLazyAnnotationInfo
- FieldMirror
- FieldTypeInferred
- FilterTreeTraverser
- FilterTypeCollector
- FindTreeTraverser
- FindTypeCollector
- FixedMirrorTreeCreator
- FixedMirrorTypeCreator
- Flag
- FlagAgnosticCompleter
- FlagAssigningCompleter
- FlagOps
- FlagValues
- FoldableConstantType
- FoldableConstantType
- ForAttachment
- ForEachTypeTraverser
- ForeachPartialTreeTraverser
- ForeachTreeTraverser
- FreeSymbol
- FreeTermSymbol
- FreeTermSymbolApi
- FreeTypeSymbol
- FreeTypeSymbolApi
- FreshNameExtractor
- Function
- Function
- FunctionApi
- FunctionExtractor
- GenPolyType
- GenericApply
- GenericApplyApi
- GlobalMirror
- GlobalPhase
- GlobalPlatform
- GlobalStats
- HKTypeVar
- Ident
- Ident
- IdentApi
- IdentExtractor
- If
- If
- IfApi
- IfExtractor
- ImplDef
- ImplDefApi
- Import
- Import
- ImportApi
- ImportExtractor
- ImportSelector
- ImportSelector
- ImportSelectorApi
- ImportSelectorExtractor
- ImportType
- ImportableAttachment
- Importer
- InfixAttachment
- InfoTransformer
- InjectDerivedValue
- InlineAnnotatedAttachment
- InlineCallsiteAttachment
- InstanceMirror
- InstantiateDependentMap
- InternalApi
- InternalTransformer
- InternalTraverser
- InternalTreeCopierOps
- InterpolatedString
- InvalidateTypeCaches
- JavaArgumentApi
- JavaKeywords
- JavaRestrictedIdentifiers
- KeepOnlyTypeConstraints
- Keywords
- Kind
- Kind
- KindErrors
- LabelDef
- LabelDef
- LabelDefApi
- LabelDefExtractor
- LazyAnnotationInfo
- LazyPolyType
- LazyTreeCopier
- LazyType
- Liftable
- Liftable
- Literal
- Literal
- LiteralAnnotArg
- LiteralApi
- LiteralExtractor
- LiteralType
- LiteralType
- LocalOwnersTraverser
- Locator
- LookupAmbiguityWarning
- LookupAmbiguous
- LookupInaccessible
- LookupNotFound
- LookupSucceeded
- MacroCompatApi
- MacroInternalApi
- MalformedType
- MappedBaseTypeSeq
- Match
- Match
- MatchApi
- MatchExtractor
- MemberDef
- MemberDefApi
- MemberScopeApi
- MethodMirror
- MethodSymbol
- MethodSymbolApi
- MethodType
- MethodType
- MethodTypeApi
- MethodTypeExtractor
- MethodValue
- Mirror
- MissingAliasControl
- MissingTypeControl
- Modifiers
- Modifiers
- ModifiersApi
- ModifiersExtractor
- ModuleClassSymbol
- ModuleDef
- ModuleDef
- ModuleDefApi
- ModuleDefExtractor
- ModuleMirror
- ModuleSymbol
- ModuleSymbolApi
- ModuleTypeRef
- MultiDefAttachment
- MultiargInfixAttachment
- Name
- NameApi
- NameHasIsEmpty
- NameLookup
- NamePos
- NameTree
- NameTreeApi
- NamedArg
- NamedArg
- NamedArgApi
- NamedArgExtractor
- NamedType
- NamesApi
- NestedAnnotArg
- New
- New
- NewApi
- NewExtractor
- NoArgsTypeRef
- NoCommonType
- NoCompilationUnit
- NoInlineCallsiteAttachment
- NoPrefix
- NoSymbol
- NoType
- NoWarnAttachment
- NonClassTypeRef
- NullaryMethodType
- NullaryMethodType
- NullaryMethodTypeApi
- NullaryMethodTypeExtractor
- NullaryOverrideAdapted
- OuterArgCanBeElided
- OverloadedArgProto
- OverloadedType
- PackageClassInfoType
- PackageClassSymbol
- PackageDef
- PackageDef
- PackageDefApi
- PackageDefExtractor
- PackageObjectClassSymbol
- PackageTypeRef
- Parens
- PatShadowAttachment
- PatVarDefAttachment
- PerRunParsing
- PerRunReporting
- PerRunReportingBase
- PermittedSubclassSymbols
- PermittedSubclasses
- PlainAttachment
- PolyType
- PolyType
- PolyTypeApi
- PolyTypeExtractor
- PosAssigner
- PostfixAttachment
- ProperTypeKind
- ProtoType
- QualTypeSymAttachment
- Quasiquote
- RawTreePrinter
- RecoverableCyclicReference
- RefTree
- RefTree
- RefTreeApi
- RefTreeExtractor
- ReferenceToBoxed
- ReferenceToBoxed
- ReferenceToBoxedApi
- ReferenceToBoxedExtractor
- RefinedType
- RefinedType
- RefinedType0
- RefinedTypeApi
- RefinedTypeExtractor
- RefinementClassSymbol
- RefinementTypeRef
- ReflectStats
- ReflectiveMirror
- ReificationSupportApi
- ReificationSupportImpl
- RepeatedType
- Return
- Return
- ReturnApi
- ReturnExtractor
- RewrappingTypeProxy
- RootSelection
- RootSymbol
- Roots
- RootsBase
- Run
- RunContextApi
- RunParsing
- RunReporting
- RuntimeClassApi
- RuntimeMirror
- SAMFunction
- Scope
- Scope
- ScopeApi
- ScopeEntry
- Select
- Select
- SelectApi
- SelectExtractor
- SelectFromArray
- SelectFromTypeTree
- SelectFromTypeTree
- SelectFromTypeTreeApi
- SelectFromTypeTreeExtractor
- SimpleTypeProxy
- SingleType
- SingleType
- SingleTypeApi
- SingleTypeExtractor
- SingletonType
- SingletonTypeApi
- SingletonTypeTree
- SingletonTypeTree
- SingletonTypeTreeApi
- SingletonTypeTreeExtractor
- StandardImporter
- StandardLiftableInstances
- StandardTypes
- StandardUnliftableInstances
- Star
- Star
- StarApi
- StarExtractor
- StaticallyAnnotatedType
- StrictTreeCopier
- StubClassSymbol
- StubSymbol
- StubTermSymbol
- SubType
- SubTypePair
- SubpatternsAttachment
- SubstMap
- SubstSymMap
- SubstSymMap
- SubstThisMap
- SubstTypeMap
- SubstWildcardMap
- Super
- Super
- SuperApi
- SuperExtractor
- SuperType
- SuperType
- SuperTypeApi
- SuperTypeExtractor
- SymLoader
- SymTree
- SymTreeApi
- Symbol
- SymbolApi
- SymbolContextApiImpl
- SymbolNames
- SymbolOps
- SymbolTableInternal
- SyntheticUnitAttachment
- Template
- Template
- TemplateApi
- TemplateExtractor
- TemplateMirror
- TermName
- TermName
- TermNameApi
- TermNameExtractor
- TermNames
- TermNamesApi
- TermSymbol
- TermSymbolApi
- TermTree
- TermTreeApi
- This
- This
- ThisApi
- ThisExtractor
- ThisSubstituter
- ThisType
- ThisType
- ThisTypeApi
- ThisTypeExtractor
- Throw
- Throw
- ThrowApi
- ThrowExtractor
- ThrownException
- Transformer
- Traverser
- Tree
- TreeApi
- TreeContextApiImpl
- TreeCopier
- TreeCopierOps
- TreeGen
- TreePrinter
- TreeReplacer
- TreeStackTraverser
- TreeSubstituter
- TreeSymSubstTraverser
- TreeSymSubstituter
- TreeTypeSubstituter
- Try
- Try
- TryApi
- TryExtractor
- TypTree
- TypTreeApi
- Type
- TypeApi
- TypeApiImpl
- TypeApply
- TypeApply
- TypeApplyApi
- TypeApplyExtractor
- TypeBounds
- TypeBounds
- TypeBoundsApi
- TypeBoundsExtractor
- TypeBoundsTree
- TypeBoundsTree
- TypeBoundsTreeApi
- TypeBoundsTreeExtractor
- TypeCollector
- TypeConKind
- TypeConKind
- TypeConstraint
- TypeDef
- TypeDef
- TypeDefApi
- TypeDefExtractor
- TypeError
- TypeFolder
- TypeMap
- TypeMapTreeSubstituter
- TypeName
- TypeName
- TypeNameApi
- TypeNameExtractor
- TypeNames
- TypeNamesApi
- TypeParamVarargsAttachment
- TypeRef
- TypeRef
- TypeRefApi
- TypeRefExtractor
- TypeSkolem
- TypeSymbol
- TypeSymbolApi
- TypeTag
- TypeTag
- TypeTraverser
- TypeTree
- TypeTree
- TypeTreeApi
- TypeTreeExtractor
- TypeTreeWithDeferredRefCheck
- TypeUnwrapper
- TypeVar
- TypeVar
- Typed
- Typed
- TypedApi
- TypedExpectingUnitAttachment
- TypedExtractor
- TypedLocator
- UnApply
- UnApply
- UnApplyApi
- UnApplyExtractor
- UndoLog
- UniqueConstantType
- UniqueErasedValueType
- UniqueLiteralType
- UniqueSingleType
- UniqueSuperType
- UniqueThisType
- UniqueType
- UniqueTypeBounds
- Unliftable
- UnmappableAnnotation
- UnnamedArg
- UntouchableTypeVar
- UseCase
- UseInvokeSpecial
- ValDef
- ValDef
- ValDefApi
- ValDefExtractor
- ValOrDefDef
- ValOrDefDef
- ValOrDefDefApi
- ValidateException
- ValidatingPosAssigner
- ValueClassDefinitions
- VarianceValidator
- VariancedTypeMap
- VirtualStringContext
- WeakTypeTag
- WeakTypeTag
- WildcardType
- abstractTypesToBounds
- adaptToNewRunMap
- async
- cleanup
- constfold
- constructors
- definitions
- delambdafy
- dropIllegalStarTypes
- dropSingletonType
- duplicateAndResetPos
- erasure
- explicitOuter
- extensionMethods
- fields
- flatten
- gen
- genBCode
- icodes
- inferKind
- lambdaLift
- mixer
- nme
- noPrint
- noSelfType
- nodePrinters
- noopTransformer
- overridingPairs
- patmat
- pendingSuperCall
- perRunCaches
- pickler
- postErasure
- refChecks
- scalaPrimitives
- specializeTypes
- statistics
- superAccessors
- tailCalls
- terminal
- tpnme
- traceSymbols
- treeBrowsers
- treeChecker
- treeInfo
- typeDebug
- typeDeconstruct
- typer
- uncurry
- unwrapToClass
- unwrapToStableClass
- unwrapWrapperTypes
- wildcardExtrapolation

o

scala.tools.nsc.Global

# treeChecker

###

#### object treeChecker extends TreeCheckers

Tree checker

Source
  Global.scala

Linear Supertypes
TreeCheckers, Analyzer, ImportTracking, AnalyzerPlugins, MacroAnnotationAttachments, StdAttachments, ContextErrors, SplainErrors, TypeDiagnostics, SplainDiagnostics, SplainFormatting, SplainFormatters, NamesDefaults, Macros, Helpers, Traces, MacroRuntimes, JavaReflectionRuntimes, Unapplies, SyntheticMethods, TreeDSL, EtaExpansion, Implicits, SplainData, Infer, Checkable, Typers, PatternTypers, TypersTracking, Tags, Adaptations, Namers, MethodSynthesis, Contexts, AnyRef, Any
Content Hierarchy

Ordering

1. Alphabetic
2. By Inheritance

Inherited

1. treeChecker
2. TreeCheckers
3. Analyzer
4. ImportTracking
5. AnalyzerPlugins
6. MacroAnnotationAttachments
7. StdAttachments
8. ContextErrors
9. SplainErrors
10. TypeDiagnostics
11. SplainDiagnostics
12. SplainFormatting
13. SplainFormatters
14. NamesDefaults
15. Macros
16. Helpers
17. Traces
18. MacroRuntimes
19. JavaReflectionRuntimes
20. Unapplies
21. SyntheticMethods
22. TreeDSL
23. EtaExpansion
24. Implicits
25. SplainData
26. Infer
27. Checkable
28. Typers
29. PatternTypers
30. TypersTracking
31. Tags
32. Adaptations
33. Namers
34. MethodSynthesis
35. Contexts
36. AnyRef
37. Any

1. Hide All
2. Show All

Visibility

1. Public
2. Protected

### Type Members

1.  trait JavaReflectionResolvers extends AnyRef
   Definition Classes
     JavaReflectionRuntimes
2.  class MacroRuntimeResolver extends tools.nsc.typechecker.Analyzer.JavaReflectionResolvers
   Definition Classes
     MacroRuntimes
3.  type Checkability = Int
   Definition Classes
     Checkable
4.  type ImportType = Global.ImportType
   Definition Classes
     Contexts
5.  type MacroContext = UnaffiliatedMacroContext { val universe: scala.tools.nsc.Global.treeChecker.global.type }
   Definition Classes
     StdAttachments
6.  type MacroRuntime = (MacroArgs) => Any

   Abstracts away resolution of macro runtimes.

   Abstracts away resolution of macro runtimes.

   Definition Classes
     MacroRuntimes
7.  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
8.  trait Adaptation extends AnyRef
   Definition Classes
     Adaptations
9.  trait AnalyzerPlugin extends AnyRef
   Definition Classes
     AnalyzerPlugins
   Annotations
     @nowarn()
10.  trait MacroPlugin extends AnyRef

    Definition Classes
      AnalyzerPlugins
    Annotations
      @nowarn()
11.  trait InferCheckable extends AnyRef
    Definition Classes
      Checkable
12.  abstract class AbsAmbiguousTypeError extends Analyzer.AbsTypeError
    Definition Classes
      ContextErrors
13.  sealed abstract class AbsTypeError extends AnyRef
    Definition Classes
      ContextErrors
14.  case class AccessTypeError(underlyingTree: Global.Tree, errMsg: String) extends Analyzer.TreeTypeError with Product with Serializable
    Definition Classes
      ContextErrors
15.  case class AmbiguousImplicitTypeError(underlyingTree: Global.Tree, errMsg: String) extends Analyzer.AbsAmbiguousTypeError with Product with Serializable
    Definition Classes
      ContextErrors
16.  case class AmbiguousTypeError(errPos: Global.Position, errMsg: String) extends Analyzer.AbsAmbiguousTypeError with Product with Serializable
    Definition Classes
      ContextErrors
17.  final case class ContextWarning(pos: Global.Position, msg: String, cat: WarningCategory, sym: Global.Symbol, actions: List[CodeAction]) extends Product with Serializable
    Definition Classes
      ContextErrors
18.  case class DivergentImplicitTypeError(underlyingTree: Global.Tree, pt0: Global.Type, sym: Global.Symbol) extends Analyzer.TreeTypeError with Product with Serializable
    Definition Classes
      ContextErrors
19.  trait ImplicitsContextErrors extends AnyRef
    Definition Classes
      ContextErrors
20.  trait InferencerContextErrors extends AnyRef
    Definition Classes
      ContextErrors
21.  trait NamerContextErrors extends AnyRef
    Definition Classes
      ContextErrors
22.  case class NormalTypeError(underlyingTree: Global.Tree, errMsg: String, actions: List[CodeAction] = Nil) extends Analyzer.TreeTypeError with Product with Serializable
    Definition Classes
      ContextErrors
23.  case class PosAndMsgTypeError(errPos: Global.Position, errMsg: String) extends Analyzer.AbsTypeError with Product with Serializable
    Definition Classes
      ContextErrors
24.  case class SymbolTypeError(underlyingSym: Global.Symbol, errMsg: String) extends Analyzer.AbsTypeError with Product with Serializable
    Definition Classes
      ContextErrors
25.  sealed abstract class TreeTypeError extends Analyzer.AbsTypeError
    Definition Classes
      ContextErrors
26.  case class TypeErrorWithUnderlyingTree(tree: Global.Tree, ex: Global.TypeError) extends Analyzer.AbsTypeError with Product with Serializable
    Definition Classes
      ContextErrors
27.  case class TypeErrorWrapper(ex: Global.TypeError, actions: List[CodeAction] = Nil) extends Analyzer.AbsTypeError with Product with Serializable
    Definition Classes
      ContextErrors
28.  trait TyperContextErrors extends AnyRef
    Definition Classes
      ContextErrors
29.  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 `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 ContextReporter records everything that is issued. It is important to note, that child Contexts created with `make` "inherit" the very same `ContextReporter` instance, whereas children spawned through `makeSilent` receive a separate, fresh buffer.

    Definition Classes
      Contexts
30.  abstract class ContextReporter extends AnyRef

    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
31.  final class ImportContext extends (Contexts.this)#Context

    A `Context` focussed on an `Import` tree

    A `Context` focussed on an `Import` tree

    Definition Classes
      Contexts
32.  class ImportInfo extends AnyRef
    Definition Classes
      Contexts
33.  class ImplicitAnnotationMsg extends AnyRef
    Definition Classes
      Implicits
34.  class ImplicitInfo extends AnyRef

    A class that records an available implicit

    A class that records an available implicit

    Definition Classes
      Implicits
35.  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
36.  class Message extends AnyRef
    Definition Classes
      Implicits
37.  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
38.  class SearchResult extends AnyRef

    The result of an implicit search

    The result of an implicit search

    Definition Classes
      Implicits
39.  final case class AdjustedTypeArgs(okParams: List[Global.Symbol], okArgs: List[Global.Type], undetParams: List[Global.Symbol], allArgs: List[Global.Type]) extends Product with Serializable
    Definition Classes
      Infer
40.  abstract class Inferencer extends Analyzer.InferencerContextErrors with Analyzer.InferCheckable

    The context-dependent inferencer part

    The context-dependent inferencer part

    Definition Classes
      Infer
41.  class NoInstance extends ControlThrowable
    Definition Classes
      Infer
42.  case class CacheAttachment(cache: Map[String, Any]) extends Product with Serializable
    Definition Classes
      MacroAnnotationAttachments
43.  implicit class RichTree extends AnyRef
    Definition Classes
      MacroAnnotationAttachments
44.  case class SymbolCompleterAttachment(info: Global.Type) extends Product with Serializable
    Definition Classes
      MacroAnnotationAttachments
45.  case class SymbolExpansionAttachment(expansion: List[Global.Tree]) extends Product with Serializable
    Definition Classes
      MacroAnnotationAttachments
46.  case class SymbolSourceAttachment(source: Global.Tree) extends Product with Serializable
    Definition Classes
      MacroAnnotationAttachments
47.  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
48.  case class Delayed(delayed: Global.Tree) extends Analyzer.MacroStatus with Product with Serializable
    Definition Classes
      Macros
49.  case class Failure(failure: Global.Tree) extends Analyzer.MacroStatus with Product with Serializable
    Definition Classes
      Macros
50.  case class Fallback(fallback: Global.Tree) extends Analyzer.MacroStatus with Product with Serializable
    Definition Classes
      Macros
51.  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
52.  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
53.  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
54.  sealed abstract class MacroStatus extends AnyRef
    Definition Classes
      Macros
55.  case class Skipped(skipped: Global.Tree) extends Analyzer.MacroStatus with Product with Serializable
    Definition Classes
      Macros
56.  case class Success(expanded: Global.Tree) extends Analyzer.MacroStatus with Product with Serializable
    Definition Classes
      Macros
57.  class ClassMethodSynthesis extends AnyRef
    Definition Classes
      MethodSynthesis
58.  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
59.  class CompleterWrapper extends Analyzer.TypeCompleter

    Wrap an existing completer to do some post/pre-processing of the completed type.

    Wrap an existing completer to do some post/pre-processing of the completed type.

    Definition Classes
      Namers
60.  trait LockingTypeCompleter extends Analyzer.TypeCompleter
    Definition Classes
      Namers
61.  abstract class Namer extends Analyzer.MethodSynth with Analyzer.NamerContextErrors
    Definition Classes
      Namers
62.  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
63.  abstract class TypeCompleter extends Global.LazyType
    Definition Classes
      Namers
64.  abstract class TypeCompleterBase[T <: Global.Tree] extends Analyzer.TypeCompleter with Analyzer.LockingTypeCompleter with Global.FlagAgnosticCompleter
    Definition Classes
      Namers
65.  class CaseApplyDefaultGetters extends AnyRef
    Definition Classes
      NamesDefaults
66.  class ConstructorDefaultsAttachment extends AnyRef
    Definition Classes
      NamesDefaults
67.  class DefaultsOfLocalMethodAttachment extends AnyRef
    Definition Classes
      NamesDefaults
68.  case class NamedApplyInfo(qual: Option[Global.Tree], targs: List[Global.Tree], vargss: List[List[Global.Tree]], blockTyper: Analyzer.Typer, original: Global.Tree) extends Product with Serializable
    Definition Classes
      NamesDefaults
69.  trait PatternTyper extends AnyRef
    Definition Classes
      PatternTypers
70.  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
71.  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
72.  case class MacroRuntimeAttachment(delayed: Boolean, typerContext: Analyzer.Context, macroContext: Option[Analyzer.MacroContext]) extends Product with Serializable
    Definition Classes
      StdAttachments
73.  case class OriginalTreeAttachment(original: Global.Tree) extends Product with Serializable

    Marks a tree that has been adapted by typer and sets the original tree that was in place before.

    Marks a tree that has been adapted by typer and sets the original tree that was in place before.

    Keeping track of the original trees were is an important feature for some compiler plugins (like Scalameta) and the incremental compiler (Zinc). In both cases, adapting trees loses information in some sense and do not allow external tools to capture some information stored in user-defined trees that are optimized away by early phases (mostly, typer).

    See how the absence of this attachment blocks Zinc: https://github.com/sbt/zinc/issues/227. Related: https://github.com/scala/scala-dev/issues/340.

    This attachment is, at the moment, only used to keep track of constant-folded constants. It has a generic wording in the hope that in the future can be reused in the same context to keep track of other adapted trees.

    Definition Classes
      StdAttachments
74.  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
75.  trait Tag extends AnyRef
    Definition Classes
      Tags
76.  case class DiffResult[T](lost: List[T], gained: List[T]) extends Product with Serializable
    Definition Classes
      TreeCheckers
77.  class TreeChecker extends Typer
    Definition Classes
      TreeCheckers
78.  case class TypeDiag(tp: Global.Type, sym: Global.Symbol) extends Ordered[(TypeDiagnostics.this)#TypeDiag] with Product with Serializable
    Definition Classes
      TypeDiagnostics
79.  trait TyperDiagnostics extends AnyRef
    Definition Classes
      TypeDiagnostics
80.  class UnusedPrivates extends Global.Traverser
    Definition Classes
      TypeDiagnostics
81.  class checkUnused extends AnyRef
    Definition Classes
      TypeDiagnostics
82.  sealed abstract class SilentResult[+T] extends AnyRef
    Definition Classes
      Typers
83.  case class SilentResultValue[+T](value: T) extends Analyzer.SilentResult[T] with Product with Serializable
    Definition Classes
      Typers
84.  class SilentTypeError extends Analyzer.SilentResult[Nothing]
    Definition Classes
      Typers
85.  abstract class Typer extends Analyzer.TyperDiagnostics with Analyzer.Adaptation with Analyzer.Tag with Analyzer.PatternTyper with Analyzer.TyperContextErrors
    Definition Classes
      Typers
86.  class ClassForCaseCompanionAttachment extends AnyRef
    Definition Classes
      Unapplies
87.  case class ImplicitError(tpe: Global.Type, candidate: Global.Tree, nesting: Int, specifics: Analyzer.ImplicitErrorSpecifics) extends Product with Serializable
    Definition Classes
      SplainData
88.  sealed trait ImplicitErrorSpecifics extends AnyRef
    Definition Classes
      SplainData
89.  trait SpecialFormatter extends AnyRef
    Definition Classes
      SplainFormatters
90.  case class ImplicitErrorLink(fromTree: Analyzer.ImplicitError, fromHistory: Analyzer.DivergentImplicitTypeError) extends Product with Serializable
    Definition Classes
      SplainFormatting
91.  case class ImplicitErrorTree(error: Analyzer.ImplicitError, children: collection.immutable.Seq[Analyzer.ImplicitErrorTree] = Nil) extends Product with Serializable
    Definition Classes
      SplainFormatting
92.  case class TypeParts(sym: Global.Symbol, tt: Global.Type) extends Product with Serializable
    Definition Classes
      SplainFormatting

### Value Members

1.  final def !=(arg0: Any): Boolean
   Definition Classes
     AnyRef → Any
2.  final def ##: Int
   Definition Classes
     AnyRef → Any
3.  final def ==(arg0: Any): Boolean
   Definition Classes
     AnyRef → Any
4.  lazy val AmbiguousSearchFailure: SearchResult
   Definition Classes
     Implicits
5.  def Delay(expanded: Global.Tree): Delayed
   Definition Classes
     Macros
6.  lazy val DivergentSearchFailure: SearchResult
   Definition Classes
     Implicits
7.  val ImportType: Global.ImportType.type
   Definition Classes
     Contexts
8.  def MacroCantExpand210xMacrosError(internalMessage: String): Nothing
   Definition Classes
     ContextErrors
9.  def MacroCantExpandIncompatibleMacrosError(internalMessage: String): Nothing
   Definition Classes
     ContextErrors
10.  def NoImplicitFoundAnnotation(tree: Global.Tree, param: Global.Symbol): (Boolean, String)

    The implicit not found message from the annotation, and whether it's a supplement message or not.

    The implicit not found message from the annotation, and whether it's a supplement message or not.

    Definition Classes
      ContextErrors
11.  def NoImplicitFoundError(tree: Global.Tree, param: Global.Symbol)(implicit context: Context): Unit
    Definition Classes
      ContextErrors
12.  val NoImplicitInfo: ImplicitInfo

    A sentinel indicating no implicit was found

    A sentinel indicating no implicit was found

    Definition Classes
      Implicits
13.  lazy val SearchFailure: SearchResult
    Definition Classes
      Implicits
14.  def SearchedPrefixImplicitInfo(pre: Global.Type): ImplicitInfo
    Definition Classes
      Implicits
15.  def Skip(expanded: Global.Tree): Skipped
    Definition Classes
      Macros
16.  val _openMacros: collection.immutable.List[reflect.macros.contexts.Context { val universe: scala.tools.nsc.Global.treeChecker.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
17.  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
18.  def adaptAnnotations(tree: Global.Tree, typer: Typer, mode: Mode, pt: Global.Type): Global.Tree

    Definition Classes
      AnalyzerPlugins
    See also

      AnalyzerPlugin.adaptAnnotations

19.  def addAnalyzerPlugin(plugin: AnalyzerPlugin): Unit

    Registers a new analyzer plugin

    Registers a new analyzer plugin

    Definition Classes
      AnalyzerPlugins
20.  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.

    Returns the extended arg list and missing parameters if any.

    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
21.  def addMacroPlugin(plugin: MacroPlugin): Unit

    Registers a new macro plugin

    Registers a new macro plugin

    Definition Classes
      AnalyzerPlugins
22.  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
23.  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
24.  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).

    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
25.  def alternatives(tree: Global.Tree): List[Global.Type]
    Definition Classes
      TypeDiagnostics
26.  def alternativesString(tree: Global.Tree): String
    Definition Classes
      TypeDiagnostics
27.  final def asInstanceOf[T0]: T0
    Definition Classes
      Any
28.  implicit def asSimpleName(s: String): SimpleName
    Definition Classes
      SplainFormatters
29.  def assertFn(cond: Boolean, msg: => Any): Unit
    Definition Classes
      TreeCheckers
30.  def attachExpansion(sym: Global.Symbol, trees: List[Global.Tree]): Global.Symbol
    Definition Classes
      MacroAnnotationAttachments
31.  def attachSource(sym: Global.Symbol, tree: Global.Tree): Global.Symbol
    Definition Classes
      MacroAnnotationAttachments
32.  def attachedExpansion(sym: Global.Symbol): Option[List[Global.Tree]]
    Definition Classes
      MacroAnnotationAttachments
33.  def attachedSource(sym: Global.Symbol): Global.Tree
    Definition Classes
      MacroAnnotationAttachments
34.  def backupCompleter(sym: Global.Symbol): Global.Symbol
    Definition Classes
      MacroAnnotationAttachments
35.  def bindMacroImpl(macroDef: Global.Symbol, macroImplRef: Global.Tree): Unit
    Definition Classes
      Macros
36.  def bracket[A](params: collection.immutable.List[A]): String
    Definition Classes
      SplainFormatting
37.  def breakInfix(types: collection.immutable.List[Formatted]): TypeRepr

    Break a list produced by flattenInfix into lines by taking two elements at a time, then appending the terminal.

    Break a list produced by flattenInfix into lines by taking two elements at a time, then appending the terminal. If the expression's length is smaller than the threshold specified via plugin parameter, return a single line.

    Definition Classes
      SplainFormatting
38.  val breakInfixLength: Int
    Definition Classes
      SplainFormatting
39.  def builtinFoundReqMsg(found: Global.Type, req: Global.Type): String
    Definition Classes
      TypeDiagnostics
40.  def canAdaptAnnotations(tree: Global.Tree, typer: Typer, mode: Mode, pt: Global.Type): Boolean

    Definition Classes
      AnalyzerPlugins
    See also

      AnalyzerPlugin.canAdaptAnnotations

41.  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
42.  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 scala/bug#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
43.  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
44.  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
45.  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
46.  def check(unit: Global.CompilationUnit): Unit
    Definition Classes
      TreeCheckers
47.  def checkTrees(): Unit
    Definition Classes
      TreeCheckers
48.  def clearDelayed(): Unit
    Definition Classes
      Macros
49.  final def clearRenamedCaseAccessors(caseclazz: Global.Symbol): Unit
    Definition Classes
      SyntheticMethods
50.  def clone(): AnyRef
    Attributes
      protected[lang]
    Definition Classes
      AnyRef
    Annotations
      @throws(classOf[java.lang.CloneNotSupportedException]) @native()
51.  def companionModuleDef(cdef: Global.ClassDef, parents: List[Global.Tree] = Nil, body: List[Global.Tree] = Nil): Global.ModuleDef
    Definition Classes
      Unapplies
52.  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
53.  def ctorNames(tpe: Global.Type): collection.immutable.List[String]
    Definition Classes
      SplainFormatting
54.  def dealias(tpe: Global.Type): Global.Type
    Definition Classes
      SplainFormatting
55.  def decideBreak(flat: FlatType, broken: => BrokenType): TypeRepr
    Definition Classes
      SplainFormatting
56.  def decodeWithKind(name: Global.Name, owner: Global.Symbol): String
    Definition Classes
      TypeDiagnostics
57.  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

58.  def deepestLevel(chain: collection.immutable.List[ImplicitError]): Int
    Definition Classes
      SplainFormatting
59.  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
60.  def defaultMacroClassloader: ClassLoader
    Definition Classes
      MacroRuntimes
61.  def diff(t1: Global.Tree, t2: Global.Tree): String
    Definition Classes
      TreeCheckers
62.  def diffList[T](xs: List[T], ys: List[T]): DiffResult[T]
    Definition Classes
      TreeCheckers
63.  def diffTemplates(t1: Global.Template, t2: Global.Template): String
    Definition Classes
      TreeCheckers
64.  def diffTrees(t1: Global.Tree, t2: Global.Tree): DiffResult[Global.Tree]
    Definition Classes
      TreeCheckers
65.  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
66.  def disambiguate(ss: List[String]): collection.immutable.List[String]
    Definition Classes
      TypeDiagnostics
67.  def enclosingMacroPosition: reflect.internal.util.Position
    Definition Classes
      Macros
68.  final def eq(arg0: AnyRef): Boolean
    Definition Classes
      AnyRef
69.  def equals(arg0: AnyRef): Boolean
    Definition Classes
      AnyRef → Any
70.  def errorFn(msg: Any): Unit
    Definition Classes
      TreeCheckers
71.  def errorFn(pos: Global.Position, msg: Any): Unit
    Definition Classes
      TreeCheckers
72.  def etaExpand(tree: Global.Tree, owner: Global.Symbol)(implicit creator: FreshNameCreator): Global.Tree

    Expand partial method application `p.f(es_1)...(es_n)`.

    Expand partial method application `p.f(es_1)...(es_n)`.

    We expand this to the following block, which evaluates the target of the application and its supplied arguments if needed (they are not stable), and then wraps a Function that abstracts over the missing arguments.

        {
          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))
        }

    This is called from typedEtaExpansion, which itself is called from

    - instantiateToMethodType (for a naked method reference), or
    - typedEta (when type checking a method value, `m _`).
    Definition Classes
      EtaExpansion
73.  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
74.  val excludedRootImportsCached: HashMap[Global.CompilationUnit, List[Global.Symbol]]
    Definition Classes
      Contexts
75.  def existentialContext(tp: Global.Type): String
    Definition Classes
      TypeDiagnostics
76.  def explainAlias(tp: Global.Type): String
    Definition Classes
      TypeDiagnostics
77.  def explainAnyVsAnyRef(found: Global.Type, req: Global.Type): String
    Definition Classes
      TypeDiagnostics
78.  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
    Annotations
      @nowarn()
79.  def extractArgs(tpe: Global.Type): collection.immutable.List[Global.Type]
    Definition Classes
      SplainFormatting
80.  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
81.  final def falseIfNoInstance(body: => Boolean): Boolean
    Definition Classes
      Infer
    Annotations
      @inline()
82.  lazy val fastTrack: FastTrack[treeChecker.this.type]
    Definition Classes
      Macros
83.  def finalOwners(tpe: Global.Type): Boolean
    Definition Classes
      TypeDiagnostics
84.  def finalize(): Unit
    Attributes
      protected[lang]
    Definition Classes
      AnyRef
    Annotations
      @throws(classOf[java.lang.Throwable])
85.  final def finishComputeParamAlias(): Unit

    Finish computation of param aliases after typechecking is completed

    Finish computation of param aliases after typechecking is completed

    Definition Classes
      Typers
86.  def flattenInfix(tpe: Infix): collection.immutable.List[Formatted]

    Turn a nested infix type structure into a flat list

    Turn a nested infix type structure into a flat list

        ::[A, ::[B, C]]] => List(A, ::, B, ::, C)

    Definition Classes
      SplainFormatting
87.  final def forArgMode(fun: Global.Tree, mode: Mode): reflect.internal.Mode
    Definition Classes
      Typers
88.  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
89.  def formatAuxSimple(tpe: Global.Type): (collection.immutable.List[String], String)
    Definition Classes
      SplainFormatting
90.  def formatDiff(left: Global.Type, right: Global.Type, top: Boolean): Formatted
    Definition Classes
      SplainFormatting
91.  val formatDiffCache: FormatCache[(Global.Type, Global.Type, Boolean), Formatted]
    Definition Classes
      SplainFormatting
92.  def formatDiffImpl(found: Global.Type, req: Global.Type, top: Boolean): Formatted
    Definition Classes
      SplainFormatting
93.  def formatDiffInfix(left: Global.Type, right: Global.Type, top: Boolean): Formatted
    Definition Classes
      SplainFormatting
94.  def formatDiffSimple(left: Global.Type, right: Global.Type): Formatted
    Definition Classes
      SplainFormatting
95.  def formatDiffSpecial(left: Global.Type, right: Global.Type, top: Boolean): Option[Formatted]
    Definition Classes
      SplainFormatting
96.  def formatFunction(args: collection.immutable.List[String]): String
    Definition Classes
      SplainFormatting
97.  def formatImplicitChainFlat(chain: collection.immutable.List[ImplicitError]): collection.immutable.List[String]
    Definition Classes
      SplainFormatting
98.  def formatImplicitChainTreeFull(chain: collection.immutable.List[ImplicitError]): collection.immutable.List[String]
    Definition Classes
      SplainFormatting
99.  def formatImplicitError(param: Global.Symbol, errors: collection.immutable.List[ImplicitError], annotationMsg: String): String
    Definition Classes
      SplainFormatting
100.  def formatIndentTree(chain: collection.immutable.List[ImplicitError], baseIndent: Int): collection.immutable.List[String]
     Definition Classes
       SplainFormatting
101.  def formatInfix[A](path: collection.immutable.List[String], simple: String, left: A, right: A, top: Boolean)(rec: (A, Boolean) => Formatted): Formatted
     Definition Classes
       SplainFormatting
102.  def formatNestedImplicit(err: ImplicitError): (String, collection.immutable.List[String], Int)
     Definition Classes
       SplainFormatting
103.  def formatNonConfBounds(err: NonconformantBounds): collection.immutable.List[String]
     Definition Classes
       SplainFormatting
104.  def formatNormalSimple(tpe: Global.Type): (collection.immutable.List[String], String)
     Definition Classes
       SplainFormatting
105.  def formatRefinement(sym: Global.Symbol): String
     Definition Classes
       SplainFormatting
106.  def formatSimpleType(tpe: Global.Type): (collection.immutable.List[String], String)
     Definition Classes
       SplainFormatting
107.  def formatSpecial[A](tpe: Global.Type, simple: String, args: collection.immutable.List[A], formattedArgs: => collection.immutable.List[Formatted], top: Boolean)(rec: (A, Boolean) => Formatted): Option[Formatted]
     Definition Classes
       SplainFormatting
108.  def formatType(tpe: Global.Type, top: Boolean): Formatted
     Definition Classes
       SplainFormatting → SplainFormatters
109.  val formatTypeCache: FormatCache[(Global.Type, Boolean), Formatted]
     Definition Classes
       SplainFormatting
110.  def formatTypeImpl(tpe: Global.Type, top: Boolean): Formatted
     Definition Classes
       SplainFormatting
111.  def formatWithInfix[A](tpe: Global.Type, args: collection.immutable.List[A], top: Boolean)(rec: (A, Boolean) => Formatted): Formatted
     Definition Classes
       SplainFormatting
112.  def formattedDiff(left: Formatted, right: Formatted): String
     Definition Classes
       SplainFormatting
113.  def foundReqMsg(found: Global.Type, req: Global.Type): String
     Definition Classes
       TypeDiagnostics
114.  def freshNameCreatorFor(context: Context): FreshNameCreator
     Definition Classes
       Typers
115.  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
116.  def fullSiteString(context: Context): String
     Definition Classes
       TypersTracking
117.  final def getClass(): Class[_ <: AnyRef]
     Definition Classes
       AnyRef → Any
     Annotations
       @native()
118.  val global: Global.this.type
     Definition Classes
       treeChecker → Analyzer → TreeDSL
119.  def globalSettings: Settings
     Definition Classes
       Macros → Traces
120.  def hasAttachedExpansion(sym: Global.Symbol): Boolean
     Definition Classes
       MacroAnnotationAttachments
121.  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
122.  val 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
123.  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
124.  def hashCode(): Int
     Definition Classes
       AnyRef → Any
     Annotations
       @native()
125.  def hideImpError(error: ImplicitError): Boolean
     Definition Classes
       SplainFormatting
126.  def implicitMessage(param: Global.Symbol, annotationMsg: String): collection.immutable.List[String]
     Definition Classes
       SplainFormatting
127.  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

128.  def indent(lines: collection.immutable.List[String], n: Int = 1, prefix: String = " "): collection.immutable.List[String]
     Definition Classes
       SplainFormatting
129.  def indentLine(line: String, n: Int = 1, prefix: String = " "): String
     Definition Classes
       SplainFormatting
130.  def indentTree(tree: collection.immutable.List[(String, collection.immutable.List[String], Int)], baseIndent: Int): collection.immutable.List[String]
     Definition Classes
       SplainFormatting
131.  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
132.  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. Consider using one of the convenience methods above. This one has many boolean levers.

     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 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 to NoPosition, then position-based services will use `tree.pos`

     returns

       A search result

     Definition Classes
       Implicits
133.  def inferImplicitByType(pt: Global.Type, context: Context, pos: Global.Position = NoPosition): SearchResult
     Definition Classes
       Implicits
134.  def inferImplicitByTypeSilent(pt: Global.Type, context: Context, pos: Global.Position = NoPosition): SearchResult
     Definition Classes
       Implicits
135.  def inferImplicitFor(pt: Global.Type, tree: Global.Tree, context: Context, reportAmbiguous: Boolean = true): SearchResult
     Definition Classes
       Implicits
136.  def inferImplicitView(from: Global.Type, to: Global.Type, tree: Global.Tree, context: Context, reportAmbiguous: Boolean, saveAmbiguousDivergent: Boolean): SearchResult
     Definition Classes
       Implicits
137.  def informFn(msg: Any): Unit
     Definition Classes
       TreeCheckers
138.  def instantiateSamFromFunction(funTp: Global.Type, samTp: Global.Type, sam: Global.Symbol): Global.Type
     Definition Classes
       Infer
139.  def isAux(tpe: Global.Type): Boolean
     Definition Classes
       SplainFormatting
140.  def isBlackbox(macroDef: Global.Symbol): Boolean
     Definition Classes
       Macros
141.  def isBlackbox(expandee: Global.Tree): Boolean
     Definition Classes
       Macros
142.  def isDynamicRewrite(tree: Global.Tree): Boolean
     Definition Classes
       StdAttachments
143.  def isExpanded(sym: Global.Symbol): Boolean
     Definition Classes
       MacroAnnotationAttachments
144.  final def isInstanceOf[T0]: Boolean
     Definition Classes
       Any
145.  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
146.  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
147.  def isMaybeExpandee(sym: Global.Symbol): Boolean
     Definition Classes
       MacroAnnotationAttachments
148.  def isNamedArg(arg: Global.Tree): Boolean
     Definition Classes
       NamesDefaults
149.  def isNotExpandable(sym: Global.Symbol): Boolean
     Definition Classes
       MacroAnnotationAttachments
150.  def isRefined(tpe: Global.Type): Boolean
     Definition Classes
       SplainFormatting
151.  def isSymbolic(tpe: Global.Type): Boolean
     Definition Classes
       SplainFormatting
152.  def isWeak(sym: Global.Symbol): Boolean
     Definition Classes
       MacroAnnotationAttachments
153.  val lastAccessCheckDetails: String
     Definition Classes
       Contexts
154.  val lastTreeToTyper: Global.Tree
     Definition Classes
       TypersTracking
155.  def linePrecedes(t1: Global.Tree, t2: Global.Tree): Boolean
     Definition Classes
       TypeDiagnostics
156.  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
157.  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
158.  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
159.  def loadMacroImplBinding(macroDef: Global.Symbol): Option[MacroImplBinding]
     Definition Classes
       Macros
160.  def macroArgs(typer: Typer, expandee: Global.Tree): MacroArgs
     Definition Classes
       Macros
161.  def macroContext(typer: Typer, prefixTree: Global.Tree, expandeeTree: Global.Tree): MacroContext
     Definition Classes
       Macros
162.  val macroDebugLite: Boolean
     Definition Classes
       Traces
163.  val macroDebugVerbose: Boolean
     Definition Classes
       Traces
164.  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`:

         @scala.reflect.macros.internal.macroImpl(
           `macro`(
             "macroEngine" = <current macro engine>,
             "isBundle" = false,
             "isBlackbox" = true,
             "signature" = List(Other),
             "methodName" = "impl",
             "className" = "Macros$"))

     Definition Classes
       Macros
165.  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

166.  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
167.  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
168.  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
169.  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
170.  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
171.  final def macroLogLite(msg: => Any): Unit
     Definition Classes
       Traces
     Annotations
       @inline()
172.  final def macroLogVerbose(msg: => Any): Unit
     Definition Classes
       Traces
     Annotations
       @inline()
173.  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
174.  def makeNamedTypes(syms: List[Global.Symbol]): collection.immutable.List[Global.NamedType]
     Definition Classes
       NamesDefaults
175.  def markDynamicRewrite(tree: Global.Tree): Global.Tree
     Definition Classes
       StdAttachments
176.  def markExpanded(sym: Global.Symbol): Global.Symbol
     Definition Classes
       MacroAnnotationAttachments
177.  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
178.  def markMaybeExpandee(sym: Global.Symbol): Global.Symbol
     Definition Classes
       MacroAnnotationAttachments
179.  def markNotExpandable(sym: Global.Symbol): Global.Symbol
     Definition Classes
       MacroAnnotationAttachments
180.  def markWeak(sym: Global.Symbol): Global.Symbol
     Definition Classes
       MacroAnnotationAttachments
181.  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
182.  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
183.  final def ne(arg0: AnyRef): Boolean
     Definition Classes
       AnyRef
184.  def newNamer(context: Context): Namer
     Definition Classes
       Namers
185.  def newTyper(context: Context): Typer
     Definition Classes
       TreeCheckers → Typers
186.  def noPrintAdapt(tree1: Global.Tree, tree2: Global.Tree): Boolean
     Definition Classes
       TypersTracking
187.  def noPrintTyping(t: Global.Tree): Boolean
     Definition Classes
       TypersTracking
188.  def notAnyRefMessage(found: Global.Type): String
     Definition Classes
       ContextErrors
189.  final def notify(): Unit
     Definition Classes
       AnyRef
     Annotations
       @native()
190.  final def notifyAll(): Unit
     Definition Classes
       AnyRef
     Annotations
       @native()
191.  def notifyUndetparamsAdded(newUndets: List[Global.Symbol]): Unit
     Definition Classes
       Macros
192.  def notifyUndetparamsInferred(undetNoMore: List[Global.Symbol], inferreds: List[Global.Type]): Unit
     Definition Classes
       Macros
193.  def onTreeCheckerError(pos: Global.Position, msg: String): Unit
     Attributes
       protected
     Definition Classes
       TreeCheckers → Contexts
194.  def openMacros: collection.immutable.List[reflect.macros.contexts.Context { val universe: scala.tools.nsc.Global.treeChecker.global.type }]
     Definition Classes
       Macros
195.  def pathPrefix: (collection.immutable.List[String]) => String
     Definition Classes
       SplainFormatting
196.  def pluginsEnsureCompanionObject(namer: Namer, cdef: Global.ClassDef, creator: (Global.ClassDef) => Global.Tree = companionModuleDef(_)): Global.Symbol

     Definition Classes
       AnalyzerPlugins
     See also

       MacroPlugin.pluginsEnsureCompanionObject

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

     Definition Classes
       AnalyzerPlugins
     See also

       MacroPlugin.pluginsEnterStats

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

     Definition Classes
       AnalyzerPlugins
     See also

       MacroPlugin.pluginsEnterSym

199.  def pluginsIsBlackbox(macroDef: Global.Symbol): Boolean

     Definition Classes
       AnalyzerPlugins
     See also

       MacroPlugin.pluginsIsBlackbox

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

     Definition Classes
       AnalyzerPlugins
     See also

       MacroPlugin.pluginsMacroArgs

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

     Definition Classes
       AnalyzerPlugins
     See also

       MacroPlugin.pluginsMacroExpand

202.  def pluginsMacroRuntime(expandee: Global.Tree): MacroRuntime

     Definition Classes
       AnalyzerPlugins
     See also

       MacroPlugin.pluginsMacroRuntime

203.  def pluginsNoImplicitFoundError(param: Global.Symbol, errors: List[ImplicitError], initial: String): String

     Definition Classes
       AnalyzerPlugins
     See also

       AnalyzerPlugin.noImplicitFoundError

204.  def pluginsNotifyImplicitSearch(search: ImplicitSearch): Unit

     Definition Classes
       AnalyzerPlugins
     See also

       AnalyzerPlugin.pluginsImplicitSearch

205.  def pluginsNotifyImplicitSearchResult(result: SearchResult): Unit

     Definition Classes
       AnalyzerPlugins
     See also

       AnalyzerPlugin.pluginsImplicitSearchResult

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

     Definition Classes
       AnalyzerPlugins
     See also

       AnalyzerPlugin.pluginsPt

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

     Definition Classes
       AnalyzerPlugins
     See also

       AnalyzerPlugin.pluginsTypeSig

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

     Definition Classes
       AnalyzerPlugins
     See also

       AnalyzerPlugin.pluginsTypeSigAccessor

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

     Definition Classes
       AnalyzerPlugins
     See also

       AnalyzerPlugin.pluginsTyped

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

     Definition Classes
       AnalyzerPlugins
     See also

       MacroPlugin.pluginsTypedMacroBody

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

     Definition Classes
       AnalyzerPlugins
     See also

       AnalyzerPlugin.pluginsTypedReturn

212.  def popMacroContext(): Unit
     Definition Classes
       Macros
213.  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
214.  def posstr(p: Global.Position): String
     Definition Classes
       TreeCheckers
215.  def printingOk(t: Global.Tree): Boolean
     Definition Classes
       TypersTracking
216.  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
217.  def pushMacroContext(c: MacroContext): Unit
     Definition Classes
       Macros
218.  def qualifiedName(path: collection.immutable.List[String], name: FormattedName): String
     Definition Classes
       SplainFormatting
219.  def recordImportContext(ctx: Context): Unit
     Definition Classes
       ImportTracking
220.  def recordImportUsage(info: ImportInfo, sel: Global.ImportSelector): Unit
     Definition Classes
       ImportTracking
221.  final def recursivelyFinal(tpe: Global.Type): Boolean
     Definition Classes
       TypeDiagnostics
     Annotations
       @tailrec()
222.  def registerImport(ctx: Context, imp: Global.Import): Unit
     Definition Classes
       Contexts
223.  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, and positional args don't appear after named ones.

     Definition Classes
       NamesDefaults
224.  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
225.  def resetContexts(): Unit
     Definition Classes
       Contexts
226.  def resetDocComments(): Unit
     Definition Classes
       Typers
227.  def resetImplicits(): Unit
     Definition Classes
       Implicits
228.  def resetTyper(): Unit
     Definition Classes
       Typers
229.  def restoreCompleter(sym: Global.Symbol): Unit
     Definition Classes
       MacroAnnotationAttachments
230.  def restrictionError(pos: Global.Position, unit: Global.CompilationUnit, msg: String): Unit
     Definition Classes
       TypeDiagnostics
231.  def restrictionWarning(pos: Global.Position, unit: Global.CompilationUnit, msg: String, category: WarningCategory, site: Global.Symbol): 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
232.  def rootContext(unit: Global.CompilationUnit, tree: Global.Tree = EmptyTree, throwing: Boolean = false, checking: Boolean = false): Context
     Definition Classes
       Contexts
233.  def rootContextPostTyper(unit: Global.CompilationUnit, tree: Global.Tree = EmptyTree): Context
     Definition Classes
       Contexts
234.  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. By default, that is `java.lang`, `scala`, and scala.Predef, in that order.

     - if option `-Yimports` is supplied, then that specifies the preamble imports
     - if the unit body has an import of Predef among its leading imports, or if the tree is scala.Predef, `Predef` is not imported. Similarly for any module among the preamble imports.
     - if the unit is java defined, only `java.lang` is imported

     The root imports for a unit are cached.

     Attributes
       protected
     Definition Classes
       Contexts
235.  val rootImportsCached: HashMap[Global.CompilationUnit, List[Global.Symbol]]
     Definition Classes
       Contexts
236.  def runWithUnit[T](unit: Global.CompilationUnit)(body: => Unit): Unit
     Definition Classes
       TreeCheckers
237.  def sanitizePath(path: collection.immutable.List[String]): collection.immutable.List[String]
     Definition Classes
       SplainFormatting
238.  def setAddendum(pos: Global.Position, msg: () => String): Unit
     Definition Classes
       TypeDiagnostics
239.  final val shortenImports: Boolean(false)
     Definition Classes
       Typers
240.  def showFormatted(tpe: Formatted): String
     Definition Classes
       SplainFormatting
241.  def showFormattedL(tpe: Formatted, break: Boolean): TypeRepr
     Definition Classes
       SplainFormatting
242.  val showFormattedLCache: FormatCache[(Formatted, Boolean), TypeRepr]
     Definition Classes
       SplainFormatting
243.  def showFormattedLImpl(tpe: Formatted, break: Boolean): TypeRepr
     Definition Classes
       SplainFormatting
244.  def showFormattedQualified(path: collection.immutable.List[String], name: FormattedName): TypeRepr
     Definition Classes
       SplainFormatting
245.  def showFuncParams(args: collection.immutable.List[String]): String
     Definition Classes
       SplainFormatting
246.  def showRefined(parents: collection.immutable.List[String], decls: collection.immutable.List[String]): String
     Definition Classes
       SplainFormatting
247.  def showTuple(args: collection.immutable.List[String]): String
     Definition Classes
       SplainFormatting
248.  def showType(tpe: Global.Type): String
     Definition Classes
       SplainFormatting
249.  def showTypeApply(cons: String, args: collection.immutable.List[TypeRepr], break: Boolean): TypeRepr

     If the args of an applied type constructor are multiline, create separate lines for the constructor name and the closing bracket; else return a single line.

     If the args of an applied type constructor are multiline, create separate lines for the constructor name and the closing bracket; else return a single line.

     Definition Classes
       SplainFormatting
250.  def showTypeBreakL(tpe: Global.Type): collection.immutable.List[String]
     Definition Classes
       SplainFormatting
251.  def skipImplicit(tp: Global.Type): Global.Type
     Definition Classes
       Infer
252.  def solvedTypes(tvars: List[Global.TypeVar], tparams: List[Global.Symbol], getVariance: Extractor[Global.Symbol], 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`

     getVariance

       Function to extract variances of type parameters; we need to reverse solution direction for all contravariant variables.

     upper

       When `true` search for max solution else min.

     Definition Classes
       Infer
     Exceptions thrown
253.  val specialFormatters: collection.immutable.List[SpecialFormatter]
     Definition Classes
       SplainFormatting
254.  def splainFoundReqMsg(found: Global.Type, req: Global.Type): String
     Definition Classes
       SplainDiagnostics
255.  def splainPushImplicitSearchFailure(implicitTree: Global.Tree, expectedType: Global.Type, originalError: AbsTypeError): Unit
     Definition Classes
       SplainErrors
256.  def splainPushNonconformantBonds(tpe: Global.Type, candidate: Global.Tree, targs: List[Global.Type], tparams: List[Global.Symbol], originalError: Option[AbsTypeError]): Unit
     Definition Classes
       SplainErrors
257.  def splainPushNotFound(tree: Global.Tree, param: Global.Symbol): Unit
     Definition Classes
       SplainErrors
258.  def splainPushOrReportNotFound(tree: Global.Tree, param: Global.Symbol, annotationMsg: String): String
     Definition Classes
       SplainErrors
259.  def splitChains(errors: collection.immutable.List[ImplicitError]): collection.immutable.List[collection.immutable.List[ImplicitError]]
     Definition Classes
       SplainFormatting
260.  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
261.  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
262.  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
263.  def standardMacroRuntime(expandee: Global.Tree): MacroRuntime
     Definition Classes
       MacroRuntimes
264.  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
265.  def stripModules(path: collection.immutable.List[String], name: FormattedName): String
     Definition Classes
       SplainFormatting
266.  def stripType(tpe: Global.Type): (collection.immutable.List[String], String)
     Definition Classes
       SplainFormatting
267.  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
268.  def suppressMacroExpansion(tree: Global.Tree): tree.type

     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
269.  def symbolPath(sym: Global.Symbol): collection.immutable.List[String]
     Definition Classes
       SplainFormatting
270.  final def synchronized[T0](arg0: => T0): T0
     Definition Classes
       AnyRef
271.  def toString(): String
     Definition Classes
       AnyRef → Any
272.  lazy val tpeOfTree: HashMap[Global.Tree, Global.Type]
     Definition Classes
       TreeCheckers
273.  def tpe_s(tp: Global.Type, colorize: (String) => String): String
     Definition Classes
       TypersTracking
274.  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

     tree

       the function application tree

     argPos

       a function mapping arguments from their current position to the position specified by the method type. example: def foo(a: Int, b: String) foo(b = "1", a = 2) calls transformNamedApplication(Apply(foo, List("1", 2), { 0 => 1, 1 => 0 })

     returns

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

     Definition Classes
       NamesDefaults
275.  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
276.  def treeSymTypeMsg(tree: Global.Tree): String
     Definition Classes
       TypeDiagnostics
277.  def truncateDecls(decls: collection.immutable.List[Formatted]): Boolean
     Definition Classes
       SplainFormatting
278.  def typePatternAdvice(sym: Global.Symbol, ptSym: Global.Symbol): String
     Definition Classes
       TypeDiagnostics
279.  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
280.  def typerShouldExpandDeferredMacros: Boolean
     Definition Classes
       Macros
281.  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
282.  def unapplyMember(tp: Global.Type): Global.Symbol

     Filters out unapplies with invalid shapes: extractor methods must have either one unary param list or one unary param list and an implicit param list.

     Filters out unapplies with invalid shapes: extractor methods must have either one unary param list or one unary param list and an implicit param list.

     Definition Classes
       Unapplies
283.  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.

     TODO: is it wise to create new symbols simply to generate error message? is this safe in interactive/resident mode?

     Definition Classes
       TypeDiagnostics
284.  def unmarkDynamicRewrite(tree: Global.Tree): Global.Tree
     Definition Classes
       StdAttachments
285.  def unmarkExpanded(sym: Global.Symbol): Global.Symbol
     Definition Classes
       MacroAnnotationAttachments
286.  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
287.  def unmarkWeak(sym: Global.Symbol): Global.Symbol
     Definition Classes
       MacroAnnotationAttachments
288.  def unsuppressMacroExpansion(tree: Global.Tree): tree.type

     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
289.  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
290.  final def validateUnapplyMember(tp: Global.Type): typechecker.Unapplies.UnapplyMemberResult.Value
     Definition Classes
       Unapplies
     Annotations
       @tailrec()
291.  final def wait(): Unit
     Definition Classes
       AnyRef
     Annotations
       @throws(classOf[java.lang.InterruptedException])
292.  final def wait(arg0: Long, arg1: Int): Unit
     Definition Classes
       AnyRef
     Annotations
       @throws(classOf[java.lang.InterruptedException])
293.  final def wait(arg0: Long): Unit
     Definition Classes
       AnyRef
     Annotations
       @throws(classOf[java.lang.InterruptedException]) @native()
294.  def warnUnusedImports(unit: Global.CompilationUnit): Unit
     Definition Classes
       ImportTracking
295.  def withAddendum(pos: Global.Position): (String) => String
     Definition Classes
       TypeDiagnostics
296.  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
297.  def wrapParens(expr: String, top: Boolean): String
     Definition Classes
       SplainFormatting
298.  def wrapParensRepr(tpe: TypeRepr, top: Boolean): TypeRepr
     Definition Classes
       SplainFormatting
299.  object CODE
     Definition Classes
       TreeDSL
300.  object namerFactory extends SubComponent
     Definition Classes
       Analyzer
301.  object packageObjects extends SubComponent
     Definition Classes
       Analyzer
302.  object typerFactory extends SubComponent
     Definition Classes
       Analyzer
303.  object Checkability
     Definition Classes
       Checkable
304.  object ErrorUtils
     Definition Classes
       ContextErrors
305.  object NamesDefaultsErrorsGen
     Definition Classes
       ContextErrors
306.  object NoContext extends (Contexts.this)#Context
     Definition Classes
       Contexts
307.  object Function1

     An extractor for unary function types arg => res

     An extractor for unary function types arg => res

     Definition Classes
       Implicits
308.  object HasMember

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

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

     Definition Classes
       Implicits
309.  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
310.  object ImplicitAmbiguousMsg extends Analyzer.ImplicitAnnotationMsg
     Definition Classes
       Implicits
311.  object ImplicitNotFoundMsg extends Analyzer.ImplicitAnnotationMsg
     Definition Classes
       Implicits
312.  object OpenImplicit extends java.io.Serializable
     Definition Classes
       Implicits
313.  object Shadower
     Definition Classes
       Implicits
314.  object approximateAbstracts extends Global.TypeMap
     Definition Classes
       Infer
315.  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
316.  object toOrigin extends Global.TypeMap
     Definition Classes
       Infer
317.  case object WeakSymbolAttachment extends Product with Serializable
     Definition Classes
       MacroAnnotationAttachments
318.  object MacroImplBinding extends java.io.Serializable
     Definition Classes
       Macros
319.  object NamedApplyBlock
     Definition Classes
       NamesDefaults
320.  case 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 scala/bug#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
321.  case object MacroImplRefAttachment extends Product with Serializable

     Definition Classes
       StdAttachments
     See also

       markMacroImplRef

322.  case 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
323.  object SymbolTracker extends Global.Traverser

     This is a work in progress, don't take it too seriously.

     This is a work in progress, don't take it too seriously.

     Definition Classes
       TreeCheckers
324.  object UnusedPrivates
     Definition Classes
       TypeDiagnostics
325.  object checkDead
     Definition Classes
       TypeDiagnostics
326.  object SilentTypeError
     Definition Classes
       Typers
327.  object checkNoEscaping extends Global.TypeMap

     Check that type of given tree does not contain local or private components.

     Check that type of given tree does not contain local or private components.

     Definition Classes
       Typers
328.  object typingStack
     Definition Classes
       TypersTracking
329.  object HasUnapply
     Definition Classes
       Unapplies
330.  object UnapplyMemberResult extends Enumeration
     Definition Classes
       Unapplies
331.  object ImplicitError extends java.io.Serializable
     Definition Classes
       SplainData
332.  object ImplicitErrorSpecifics
     Definition Classes
       SplainData
333.  object ImplicitErrors
     Definition Classes
       SplainData
334.  object ByNameFormatter extends Analyzer.SpecialFormatter
     Definition Classes
       SplainFormatters
335.  object FunctionFormatter extends Analyzer.SpecialFormatter
     Definition Classes
       SplainFormatters
336.  object Refined
     Definition Classes
       SplainFormatters
337.  object RefinedFormatter extends Analyzer.SpecialFormatter
     Definition Classes
       SplainFormatters
338.  object TupleFormatter extends Analyzer.SpecialFormatter
     Definition Classes
       SplainFormatters
339.  object ImplicitErrorLink extends java.io.Serializable
     Definition Classes
       SplainFormatting
340.  object ImplicitErrorTree extends java.io.Serializable
     Definition Classes
       SplainFormatting

### Deprecated Value Members

1.  def inferImplicit(tree: Global.Tree, pt: Global.Type, reportAmbiguous: Boolean, isView: Boolean, context: Context, saveAmbiguousDivergent: Boolean): SearchResult
   Definition Classes
     Implicits
   Annotations
     @deprecated
   Deprecated

     (Since version 2.12.0-M4) Unused in scalac

2.  def inferImplicit(tree: Global.Tree, pt: Global.Type, reportAmbiguous: Boolean, isView: Boolean, context: Context): SearchResult
   Definition Classes
     Implicits
   Annotations
     @deprecated
   Deprecated

     (Since version 2.12.0-M4) Unused in scalac

3.  def mkTypeCompleter(t: Global.Tree)(c: (Global.Symbol) => Unit): TypeCompleterBase[Global.Tree]
   Definition Classes
     Namers
   Annotations
     @deprecated
   Deprecated

     (Since version 2.12.2) Instantiate TypeCompleterBase (for monomorphic, non-wrapping completer) or CompleterWrapper directly.

### Inherited from TreeCheckers

### Inherited from Analyzer

### Inherited from ImportTracking

### Inherited from AnalyzerPlugins

### Inherited from MacroAnnotationAttachments

### Inherited from StdAttachments

### Inherited from ContextErrors

### Inherited from SplainErrors

### Inherited from TypeDiagnostics

### Inherited from SplainDiagnostics

### Inherited from SplainFormatting

### Inherited from SplainFormatters

### 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 SplainData

### 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 AnyRef

### Inherited from Any

### Ungrouped