scala.tools.nsc.transform.SpecializeTypes

# SpecializationDuplicator

#### class SpecializationDuplicator extends Duplicator

Introduced to fix SI-7343: Phase ordering problem between Duplicators and Specialization. brief explanation: specialization rewires class parents during info transformation, and the new info then guides the tree changes. But if a symbol is created during duplication, which runs after specialization, its info is not visited and thus the corresponding tree is not specialized. One manifestation is the following: ```object Test { class Parent[@specialized(Int) T]```

def spec_method[@specialized(Int) T](t: T, expectedXSuper: String) = { class X extends Parent[T]() // even in the specialized variant, the local X class // doesn't extend Parent$mcI$sp, since its symbol has // been created after specialization and was not seen // by specialzation's info transformer. ... } } ```We fix this by forcing duplication to take place before specialization.```

Note: The constructors phase (which also uses duplication) comes after erasure and uses the post-erasure typer => we must protect it from the beforeSpecialization phase shifting.

Linear Supertypes
Duplicator, Duplicators, Analyzer, AnalyzerPlugins, StdAttachments, ContextErrors, TypeDiagnostics, NamesDefaults, Macros, Helpers, Traces, MacroRuntimes, JavaReflectionRuntimes, FastTrack, Unapplies, SyntheticMethods, TreeDSL, EtaExpansion, Implicits, Infer, Checkable, Typers, PatternTypers, TypersTracking, Tags, Adaptations, Namers, MethodSynthesis, Contexts, AnyRef, Any
Type Hierarchy Learn more about scaladoc diagrams
Ordering

1. Alphabetic
2. By inheritance

Inherited

1. SpecializationDuplicator
2. Duplicator
3. Duplicators
4. Analyzer
5. AnalyzerPlugins
6. StdAttachments
7. ContextErrors
8. TypeDiagnostics
9. NamesDefaults
10. Macros
11. Helpers
12. Traces
13. MacroRuntimes
14. JavaReflectionRuntimes
15. FastTrack
16. Unapplies
17. SyntheticMethods
18. TreeDSL
19. EtaExpansion
20. Implicits
21. Infer
22. Checkable
23. Typers
24. PatternTypers
25. TypersTracking
26. Tags
27. Adaptations
28. Namers
29. MethodSynthesis
30. Contexts
31. AnyRef
32. Any

Implicitly

1. by any2stringadd
2. by StringFormat
3. by Ensuring
4. by ArrowAssoc

1. Hide All
2. Show all

Learn more about member selection
Visibility

1. Public
2. All

### Instance Constructors

1. #### new SpecializationDuplicator(casts: Map[Global.Symbol, Global.Type])

### Type Members

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

   Definition Classes
     ContextErrors

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

   Definition Classes
     ContextErrors

3. #### trait Adaptation extends AnyRef

   Definition Classes
     Adaptations

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

   Definition Classes
     ContextErrors

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

   Definition Classes
     ContextErrors

6. #### trait AnalyzerPlugin extends AnyRef

   Definition Classes
     AnalyzerPlugins

7. #### class BodyDuplicator extends Duplicator.BodyDuplicator

   Definition Classes
     Duplicator

8. #### class ClassForCaseCompanionAttachment extends AnyRef

   Definition Classes
     Unapplies

9. #### class ClassMethodSynthesis extends AnyRef

   Definition Classes
     MethodSynthesis

10. #### class ConstructorDefaultsAttachment extends AnyRef

    Definition Classes
      NamesDefaults

11. #### class Context extends AnyRef

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

12. #### class DefMacroExpander extends Analyzer.MacroExpander

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

13. #### class DefaultsOfLocalMethodAttachment extends AnyRef

    Definition Classes
      NamesDefaults

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

    Definition Classes
      Macros

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

    Definition Classes
      ContextErrors

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

    Definition Classes
      Macros

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

    Definition Classes
      Macros

18. #### final class FastTrackEntry extends ((FastTrack.this)#MacroArgs) ⇒ Any

    Definition Classes
      FastTrack

19. #### class ImplicitInfo extends AnyRef

    A class that records an available implicit

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

    A class that sets up an implicit search.

21. #### trait ImplicitsContextErrors extends AnyRef

    Definition Classes
      ContextErrors

22. #### trait ImportContext extends Analyzer.Context

    A `Context` focussed on an `Import` tree

23. #### class ImportInfo extends AnyRef

    Definition Classes
      Contexts

24. #### type ImportType = Global.ImportType

    Definition Classes
      Contexts

25. #### trait InferCheckable extends AnyRef

    Definition Classes
      Checkable

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

    The context-dependent inferencer part

27. #### trait InferencerContextErrors extends AnyRef

    Definition Classes
      ContextErrors

28. #### trait JavaReflectionResolvers extends AnyRef

    Definition Classes
      JavaReflectionRuntimes

29. #### trait LockingTypeCompleter extends Analyzer.TypeCompleter

    Definition Classes
      Namers

30. #### 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.

31. #### type MacroContext = UnaffiliatedMacroContext { val universe: SpecializationDuplicator.this.global.type }

    Definition Classes
      StdAttachments

32. #### abstract class MacroExpander extends AnyRef

    Performs macro expansion:

33. #### 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.

34. #### 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.

35. #### 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.

36. #### trait MacroPlugin extends AnyRef

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

    Abstracts away resolution of macro runtimes.

    Abstracts away resolution of macro runtimes.

    Definition Classes
      MacroRuntimes

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

    Definition Classes
      StdAttachments

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

    Definition Classes
      MacroRuntimes

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

    Definition Classes
      Macros

41. #### trait MethodSynth extends AnyRef

    There are two key methods in here.

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

    Definition Classes
      NamesDefaults

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

    Definition Classes
      Namers

44. #### trait NamerContextErrors extends AnyRef

    Definition Classes
      ContextErrors

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

    Definition Classes
      Infer

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

    Definition Classes
      ContextErrors

47. #### 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.

48. #### trait PatternTyper extends AnyRef

    Definition Classes
      PatternTypers

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

    A class representing a lazy type with known type parameters.

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

    Definition Classes
      ContextErrors

51. #### final class ReportBuffer extends AnyRef

    A buffer for warnings and errors that are accumulated during speculative type checking.

52. #### class SearchResult extends AnyRef

    The result of an implicit search

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

    Definition Classes
      Typers

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

    Definition Classes
      Typers

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

    Definition Classes
      Typers

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

    Definition Classes
      Macros

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

    Definition Classes
      Macros

58. #### 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.

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

    Definition Classes
      ContextErrors

60. #### trait Tag extends AnyRef

    Definition Classes
      Tags

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

    Definition Classes
      ContextErrors

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

    Definition Classes
      Namers

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

    Definition Classes
      TypeDiagnostics

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

    Definition Classes
      ContextErrors

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

    Definition Classes
      ContextErrors

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

    Definition Classes
      Typers

67. #### trait TyperContextErrors extends AnyRef

    Definition Classes
      ContextErrors

68. #### trait TyperDiagnostics extends AnyRef

    Definition Classes
      TypeDiagnostics

69. #### 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

### Value Members

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

   Definition Classes
     AnyRef → Any

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

   Definition Classes
     AnyRef → Any

3. #### def +(other: String): String

   Implicit information
     This member is added by an implicit conversion from SpecializationDuplicator to any2stringadd[SpecializationDuplicator] performed by method any2stringadd in scala.Predef.
   Definition Classes
     any2stringadd

4. #### def ->[B](y: B): (SpecializationDuplicator, B)

   Implicit information
     This member is added by an implicit conversion from SpecializationDuplicator to ArrowAssoc[SpecializationDuplicator] performed by method ArrowAssoc in scala.Predef.
   Definition Classes
     ArrowAssoc
   Annotations
     @inline()

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

   Definition Classes
     AnyRef → Any

6. #### lazy val AmbiguousSearchFailure: SearchResult

   Definition Classes
     Implicits

7. #### object CODE

   Definition Classes
     TreeDSL

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

   Definition Classes
     Macros

9. #### lazy val DivergentSearchFailure: SearchResult

   Definition Classes
     Implicits

10. #### 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.

11. #### object ErrorUtils

    Definition Classes
      ContextErrors

12. #### object Function1

    An extractor for unary function types arg => res

13. #### object HasMember

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

14. #### object HasMethodMatching

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

15. #### object HasUnapply

    Definition Classes
      Unapplies

16. #### object ImplicitNotFoundMsg

    Definition Classes
      Implicits

17. #### val ImportType: Global.ImportType.type

    Definition Classes
      Contexts

18. #### object MacroImplBinding extends Serializable

    Definition Classes
      Macros

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

20. #### object NamesDefaultsErrorsGen

    Definition Classes
      ContextErrors

21. #### object NoContext extends Analyzer.Context

    Definition Classes
      Contexts

22. #### val NoImplicitInfo: ImplicitInfo

    A sentinel indicating no implicit was found

    A sentinel indicating no implicit was found

    Definition Classes
      Implicits

23. #### lazy val SearchFailure: SearchResult

    Definition Classes
      Implicits

24. #### object SilentTypeError

    Definition Classes
      Typers

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

    Definition Classes
      Macros

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

    When present, suppresses macro expansion for the host.

27. #### var _lockedCount: Int

    Definition Classes
      Namers

28. #### var _openMacros: collection.immutable.List[reflect.macros.contexts.Context { val universe: SpecializationDuplicator.this.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

29. #### 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

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

    Definition Classes
      AnalyzerPlugins
    See also

      AnalyzerPlugin.adaptAnnotations

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

    Registers a new analyzer plugin

    Registers a new analyzer plugin

    Definition Classes
      AnalyzerPlugins

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

    Extend the argument list `givenArgs` with default arguments.

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

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

    Definition Classes
      NamesDefaults

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

    Registers a new macro plugin

    Registers a new macro plugin

    Definition Classes
      AnalyzerPlugins

34. #### 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

35. #### 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

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

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

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

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

    Definition Classes
      Implicits

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

    Definition Classes
      TypeDiagnostics

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

    Definition Classes
      TypeDiagnostics

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

    Definition Classes
      Contexts

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

    Definition Classes
      Contexts

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

    Definition Classes
      Any

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

    Definition Classes
      Macros

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

    Definition Classes
      AnalyzerPlugins
    See also

      AnalyzerPlugin.canAdaptAnnotations

44. #### 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

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

    Generates copy methods for case classes.

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

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

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

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

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

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

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

    Definition Classes
      Unapplies

46. #### 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

47. #### 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

48. #### 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

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

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

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

    Definition Classes
      Unapplies

51. #### 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

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

    Definition Classes
      Macros

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

    Definition Classes
      TypeDiagnostics

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

    Decreases metalevel of the type, i.

    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

55. #### 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

56. #### lazy val defaultMacroClassloader: ClassLoader

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

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

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

    Definition Classes
      MacroRuntimes

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

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

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

    Definition Classes
      MethodSynthesis

58. #### 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

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

    Definition Classes
      TypeDiagnostics

60. #### def enclosingMacroPosition: Position

    Definition Classes
      Macros

61. #### def ensuring(cond: (SpecializationDuplicator) ⇒ Boolean, msg: ⇒ Any): SpecializationDuplicator

    Implicit information
      This member is added by an implicit conversion from SpecializationDuplicator to Ensuring[SpecializationDuplicator] performed by method Ensuring in scala.Predef.
    Definition Classes
      Ensuring

62. #### def ensuring(cond: (SpecializationDuplicator) ⇒ Boolean): SpecializationDuplicator

    Implicit information
      This member is added by an implicit conversion from SpecializationDuplicator to Ensuring[SpecializationDuplicator] performed by method Ensuring in scala.Predef.
    Definition Classes
      Ensuring

63. #### def ensuring(cond: Boolean, msg: ⇒ Any): SpecializationDuplicator

    Implicit information
      This member is added by an implicit conversion from SpecializationDuplicator to Ensuring[SpecializationDuplicator] performed by method Ensuring in scala.Predef.
    Definition Classes
      Ensuring

64. #### def ensuring(cond: Boolean): SpecializationDuplicator

    Implicit information
      This member is added by an implicit conversion from SpecializationDuplicator to Ensuring[SpecializationDuplicator] performed by method Ensuring in scala.Predef.
    Definition Classes
      Ensuring

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

    Definition Classes
      AnyRef

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

    Definition Classes
      AnyRef → Any

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

    Expand partial function applications of type `type`.

    Expand partial function applications of type `type`.

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

    tree is already attributed

    Definition Classes
      EtaExpansion

68. #### object etaExpansion

    Definition Classes
      EtaExpansion

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

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

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

    Definition Classes
      TypeDiagnostics

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

    Definition Classes
      TypeDiagnostics

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

    Definition Classes
      TypeDiagnostics

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

    Definition Classes
      TypeDiagnostics

73. #### 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

74. #### 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

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

    Definition Classes
      Infer
    Annotations
      @inline()

76. #### def fastTrack: Map[Global.Symbol, FastTrackEntry]

    A map from a set of pre-established macro symbols to their implementations.

    A map from a set of pre-established macro symbols to their implementations.

    Definition Classes
      FastTrack

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

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

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

    Attributes
      protected
    Definition Classes
      Macros

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

    Definition Classes
      Typers

80. #### 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

81. #### def formatted(fmtstr: String): String

    Implicit information
      This member is added by an implicit conversion from SpecializationDuplicator to StringFormat[SpecializationDuplicator] performed by method StringFormat in scala.Predef.
    Definition Classes
      StringFormat
    Annotations
      @inline()

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

    Definition Classes
      TypeDiagnostics

83. #### 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

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

    Definition Classes
      TypersTracking

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

    Definition Classes
      AnyRef → Any

86. #### val global: SpecializeTypes.global.type

    Definition Classes
      Duplicator → Analyzer → TreeDSL

87. #### def globalSettings: Settings

    Definition Classes
      Macros → Traces

88. #### 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

89. #### var hasPendingMacroExpansions: Boolean

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

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

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

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

    Definition Classes
      Macros

90. #### 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

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

    Definition Classes
      AnyRef → Any

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

    Increases metalevel of the type, i.

    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

93. #### 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

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

    Search for an implicit value.

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

    tree

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

    pt

      The expected type of the implicit.

    reportAmbiguous

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

    isView

      We are looking for a view

    context

      The current context

    saveAmbiguousDivergent

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

    pos

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

    returns

      A search result

    Definition Classes
      Implicits

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

    Definition Classes
      Implicits

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

    Definition Classes
      Implicits

97. #### object instantiate extends Global.TypeMap

    Map every TypeVar to its constraint.

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

    Definition Classes
      Macros

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

    Definition Classes
      Macros

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

     Definition Classes
       StdAttachments

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

     Definition Classes
       Any

102. #### 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

103. #### 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

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

     Definition Classes
       NamesDefaults

105. #### var lastAccessCheckDetails: String

     Definition Classes
       Contexts

106. #### var lastTreeToTyper: Global.Tree

     Definition Classes
       TypersTracking

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

     Definition Classes
       TypeDiagnostics

108. #### 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

109. #### 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

110. #### 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

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

     Definition Classes
       Macros

112. #### def lockedCount: Int

     Definition Classes
       Namers

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

     Definition Classes
       Macros

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

     Definition Classes
       Macros

115. #### val macroDebugLite: Boolean

     Definition Classes
       Traces

116. #### val macroDebugVerbose: Boolean

     Definition Classes
       Traces

117. #### def macroEngine: String

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

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

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

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

     Definition Classes
       Macros

118. #### 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

119. #### 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

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

     Expands a macro when a runtime (i.

     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

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

     Expands a macro when a runtime (i.

     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

122. #### 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

123. #### 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

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

     Definition Classes
       Traces
     Annotations
       @inline()

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

     Definition Classes
       Traces
     Annotations
       @inline()

126. #### 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

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

     Definition Classes
       NamesDefaults

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

     Definition Classes
       StdAttachments

129. #### 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

130. #### 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

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

     Definition Classes
       NamesDefaults

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

     Definition Classes
       Namers

133. #### object namerFactory extends SubComponent

     Definition Classes
       Analyzer

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

     Definition Classes
       AnyRef

135. #### def newBodyDuplicator(context: Context): BodyDuplicator

     Attributes
       protected
     Definition Classes
       Duplicator → Duplicators

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

     Definition Classes
       Namers

137. #### def newTyper(context: Context): Typer

     Return the special typer for duplicate method bodies.

     Return the special typer for duplicate method bodies.

     Definition Classes
       Duplicators → Typers

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

     Definition Classes
       TypersTracking

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

     Definition Classes
       TypersTracking

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

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

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

     Definition Classes
       Infer

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

     Definition Classes
       ContextErrors

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

     Definition Classes
       AnyRef

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

     Definition Classes
       AnyRef

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

     Definition Classes
       Macros

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

     Definition Classes
       Macros

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

     Attributes
       protected
     Definition Classes
       Contexts

147. #### def openMacros: collection.immutable.List[reflect.macros.contexts.Context { val universe: SpecializationDuplicator.this.global.type }]

     Definition Classes
       Macros

148. #### object packageObjects extends SubComponent

     Definition Classes
       Analyzer

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

     Definition Classes
       AnalyzerPlugins
     See also

       MacroPlugin.pluginsEnsureCompanionObject

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

     Definition Classes
       AnalyzerPlugins
     See also

       MacroPlugin.pluginsEnterStats

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

     Definition Classes
       AnalyzerPlugins
     See also

       MacroPlugin.pluginsEnterSym

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

     Definition Classes
       AnalyzerPlugins
     See also

       MacroPlugin.pluginsMacroArgs

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

     Definition Classes
       AnalyzerPlugins
     See also

       MacroPlugin.pluginsMacroExpand

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

     Definition Classes
       AnalyzerPlugins
     See also

       MacroPlugin.pluginsMacroRuntime

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

     Definition Classes
       AnalyzerPlugins
     See also

       AnalyzerPlugin.pluginsPt

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

     Definition Classes
       AnalyzerPlugins
     See also

       AnalyzerPlugin.pluginsTypeSig

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

     Definition Classes
       AnalyzerPlugins
     See also

       AnalyzerPlugin.pluginsTypeSigAccessor

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

     Definition Classes
       AnalyzerPlugins
     See also

       AnalyzerPlugin.pluginsTyped

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

     Definition Classes
       AnalyzerPlugins
     See also

       MacroPlugin.pluginsTypedMacroBody

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

     Definition Classes
       AnalyzerPlugins
     See also

       AnalyzerPlugin.pluginsTypedReturn

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

     Definition Classes
       Macros

162. #### 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

163. #### 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

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

     Definition Classes
       Macros

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

     Removes name assignments from args.

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

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

     Definition Classes
       NamesDefaults

166. #### 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

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

     Definition Classes
       Contexts

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

     Definition Classes
       Typers

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

     Definition Classes
       Implicits

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

     Definition Classes
       Typers

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

     Definition Classes
       TypeDiagnostics

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

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

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

     Definition Classes
       TypeDiagnostics

173. #### def retyped(context: Context, tree: Global.Tree, oldThis: Global.Symbol, newThis: Global.Symbol, env: Map[Global.Symbol, Global.Type]): Global.Tree

     Retype the given tree in the given context.

     Retype the given tree in the given context. Use this method when retyping a method in a different class. The typer will replace references to the this of the old class with the new class, and map symbols through the given 'env'. The environment is a map from type skolems to concrete types (see SpecializedTypes).

     Definition Classes
       SpecializationDuplicator → Duplicators

174. #### def rootContext(unit: Global.CompilationUnit, tree: Global.Tree = EmptyTree, erasedTypes: Boolean = false): Context

     Definition Classes
       Contexts

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

     List of symbols to import from in a root context.

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

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

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

     Definition Classes
       TypeDiagnostics

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

     Definition Classes
       Typers

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

     Definition Classes
       Infer

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

     Solve constraint collected in types `tvars`.

     Solve constraint collected in types `tvars`.

     tvars

       All type variables to be instantiated.

     tparams

       The type parameters corresponding to `tvars`

     variances

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

     upper

       When `true` search for max solution else min.

     Definition Classes
       Infer
     Exceptions thrown
       NoInstance

180. #### 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

181. #### 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

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

     Definition Classes
       MacroRuntimes

183. #### 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

184. #### 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

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

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

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

     Definition Classes
       StdAttachments

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

     Definition Classes
       AnyRef

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

     Definition Classes
       AnyRef → Any

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

     Definition Classes
       TypersTracking

189. #### 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.

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

     typer

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

     mode

       the mode to use for calling typer.doTypedApply

     pt

       the expected type for calling typer.doTypedApply

     returns

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

     Definition Classes
       NamesDefaults

190. #### 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

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

     Definition Classes
       Typers

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

     Definition Classes
       TypeDiagnostics

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

     Definition Classes
       TypeDiagnostics

194. #### 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

195. #### object typerFactory extends SubComponent

     Definition Classes
       Analyzer

196. #### 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

197. #### object typingStack

     Definition Classes
       TypersTracking

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

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

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

     Definition Classes
       Unapplies

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

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

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

     Definition Classes
       TypeDiagnostics

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

     Definition Classes
       StdAttachments

201. #### 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

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

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

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

     Definition Classes
       StdAttachments

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

     Transforms c.

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

     Definition Classes
       Helpers

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

     Definition Classes
       AnyRef
     Annotations
       @throws( ... )

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

     Definition Classes
       AnyRef
     Annotations
       @throws( ... )

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

     Definition Classes
       AnyRef
     Annotations
       @throws( ... )

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

     Definition Classes
       Contexts

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

     Definition Classes
       TypeDiagnostics

209. #### 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

210. #### def →[B](y: B): (SpecializationDuplicator, B)

     Implicit information
       This member is added by an implicit conversion from SpecializationDuplicator to ArrowAssoc[SpecializationDuplicator] performed by method ArrowAssoc in scala.Predef.
     Definition Classes
       ArrowAssoc

### Inherited from Duplicator

### Inherited from Duplicators

### Inherited from Analyzer

### Inherited from AnalyzerPlugins

### Inherited from StdAttachments

### Inherited from ContextErrors

### Inherited from TypeDiagnostics

### Inherited from NamesDefaults

### Inherited from Macros

### Inherited from Helpers

### Inherited from Traces

### Inherited from MacroRuntimes

### Inherited from JavaReflectionRuntimes

### Inherited from FastTrack

### Inherited from Unapplies

### Inherited from SyntheticMethods

### Inherited from TreeDSL

### Inherited from EtaExpansion

### Inherited from Implicits

### Inherited from Infer

### Inherited from Checkable

### Inherited from Typers

### Inherited from PatternTypers

### Inherited from TypersTracking

### Inherited from Tags

### Inherited from Adaptations

### Inherited from Namers

### Inherited from MethodSynthesis

### Inherited from Contexts

### Inherited from AnyRef

### Inherited from Any

### Inherited by implicit conversion any2stringadd from SpecializationDuplicator to any2stringadd[SpecializationDuplicator]

### Inherited by implicit conversion StringFormat from SpecializationDuplicator to StringFormat[SpecializationDuplicator]

### Inherited by implicit conversion Ensuring from SpecializationDuplicator to Ensuring[SpecializationDuplicator]

### Inherited by implicit conversion ArrowAssoc from SpecializationDuplicator to ArrowAssoc[SpecializationDuplicator]

### Ungrouped