scala.tools.nsc.Global

treeChecker

object treeChecker extends TreeCheckers

Tree checker

Linear Supertypes
Content Hierarchy Learn more about scaladoc diagrams
Ordering
  1. Alphabetic
  2. By inheritance
Inherited
  1. treeChecker
  2. TreeCheckers
  3. Analyzer
  4. AnalyzerPlugins
  5. StdAttachments
  6. ContextErrors
  7. TypeDiagnostics
  8. NamesDefaults
  9. Macros
  10. Traces
  11. FastTrack
  12. Unapplies
  13. SyntheticMethods
  14. TreeDSL
  15. EtaExpansion
  16. Variances
  17. Implicits
  18. Infer
  19. Checkable
  20. Typers
  21. Tags
  22. Adaptations
  23. Modes
  24. Namers
  25. MethodSynthesis
  26. Contexts
  27. AnyRef
  28. Any
  1. Hide All
  2. Show all
Learn more about member selection
Visibility
  1. Public
  2. All

Type Members

  1. trait AbsTypeError extends Throwable

    Definition Classes
    ContextErrors
  2. trait Adaptation extends AnyRef

    Definition Classes
    Adaptations
  3. case class AmbiguousTypeError(underlyingTree: Global.Tree, errPos: Global.Position, errMsg: String, kind: ErrorKind = ...) extends Throwable with Analyzer.AbsTypeError with Product with Serializable

    Definition Classes
    ContextErrors
  4. trait AnalyzerPlugin extends AnyRef

    Definition Classes
    AnalyzerPlugins
  5. class ClassForCaseCompanionAttachment extends AnyRef

    Definition Classes
    Unapplies
  6. class ClassMethodSynthesis extends AnyRef

    Definition Classes
    MethodSynthesis
  7. class ConstructorDefaultsAttachment extends AnyRef

    Definition Classes
    NamesDefaults
  8. class Context extends AnyRef

    Definition Classes
    Contexts
  9. class DefaultsOfLocalMethodAttachment extends AnyRef

    Definition Classes
    NamesDefaults
  10. case class DivergentImplicitTypeError(tree: Global.Tree, pt0: Global.Type, sym: Global.Symbol) extends Throwable with Analyzer.AbsTypeError with Product with Serializable

    Definition Classes
    ContextErrors
  11. case class FastTrackEntry(sym: nsc.Global.Symbol, expander: (FastTrack.this)#FastTrackExpander) extends Product with Serializable

    Definition Classes
    FastTrack
  12. type FastTrackExpander = PartialFunction[(MacroContext, Global.Tree), Global.Tree]

    Definition Classes
    FastTrack
  13. class ImplicitInfo extends AnyRef

    A class that records an available implicit

  14. class ImplicitSearch extends Analyzer.Typer with Analyzer.ImplicitsContextErrors

    A class that sets up an implicit search.

  15. trait ImplicitsContextErrors extends AnyRef

    Definition Classes
    ContextErrors
  16. class ImportInfo extends AnyRef

    Definition Classes
    Contexts
  17. case class ImportType(expr: Global.Tree) extends Global.Type with Product with Serializable

    Definition Classes
    Contexts
  18. trait InferCheckable extends AnyRef

    Definition Classes
    Checkable
  19. class Inferencer extends Analyzer.InferencerContextErrors with Analyzer.InferCheckable

    The context-dependent inferencer part

  20. trait InferencerContextErrors extends AnyRef

    Definition Classes
    ContextErrors
  21. trait LockingTypeCompleter extends Analyzer.TypeCompleter

    Definition Classes
    Namers
  22. 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.

  23. type MacroContext = UnaffiliatedMacroContext { val universe: scala.tools.nsc.Global.treeChecker.global.type }

    Definition Classes
    StdAttachments
  24. trait MacroErrors extends AnyRef

    Definition Classes
    ContextErrors
  25. type MacroRuntime = (MacroArgs) ⇒ Any

    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
    Macros
  26. case class MacroRuntimeAttachment(delayed: Boolean, typerContext: Analyzer.Context, macroContext: Option[Analyzer.MacroContext]) extends Product with Serializable

    Definition Classes
    StdAttachments
  27. class MacroTyper extends Analyzer.MacroErrors

    Definition Classes
    Macros
  28. trait MethodSynth extends AnyRef

    There are two key methods in here.

  29. 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
  30. abstract class Namer extends Analyzer.MethodSynth with Analyzer.NamerContextErrors

    Definition Classes
    Namers
  31. trait NamerContextErrors extends AnyRef

    Definition Classes
    ContextErrors
  32. class NoInstance extends Throwable with ControlThrowable

    Definition Classes
    Infer
  33. case class NormalTypeError(underlyingTree: Global.Tree, errMsg: String, kind: ErrorKind = ...) extends Throwable with Analyzer.AbsTypeError with Product with Serializable

    Definition Classes
    ContextErrors
  34. 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.

  35. class PolyTypeCompleter extends Analyzer.TypeCompleter with Analyzer.LockingTypeCompleter with Global.FlagAgnosticCompleter

    A class representing a lazy type with known type parameters.

  36. case class PosAndMsgTypeError(errPos: Global.Position, errMsg: String, kind: ErrorKind = ...) extends Throwable with Analyzer.AbsTypeError with Product with Serializable

    Definition Classes
    ContextErrors
  37. class SearchResult extends AnyRef

    The result of an implicit search

  38. sealed abstract class SilentResult[+T] extends AnyRef

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

    Definition Classes
    Typers
  40. case class SilentTypeError(err: Analyzer.AbsTypeError) extends Analyzer.SilentResult[Nothing] with Product with Serializable

    Definition Classes
    Typers
  41. case class SymbolTypeError(underlyingSym: Global.Symbol, errMsg: String, kind: ErrorKind = ...) extends Throwable with Analyzer.AbsTypeError with Product with Serializable

    Definition Classes
    ContextErrors
  42. trait Tag extends AnyRef

    Definition Classes
    Tags
  43. class TreeChecker extends Typer

    Definition Classes
    TreeCheckers
  44. abstract class TypeCompleter extends Global.LazyType

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

    Definition Classes
    TypeDiagnostics
  46. case class TypeErrorWithUnderlyingTree(tree: Global.Tree, ex: Global.TypeError, kind: ErrorKind = ...) extends Throwable with Analyzer.AbsTypeError with Product with Serializable

    Definition Classes
    ContextErrors
  47. case class TypeErrorWrapper(ex: Global.TypeError, kind: ErrorKind = ...) extends Throwable with Analyzer.AbsTypeError with Product with Serializable

    Definition Classes
    ContextErrors
  48. abstract class Typer extends Analyzer.TyperDiagnostics with Analyzer.Adaptation with Analyzer.Tag with Analyzer.TyperContextErrors

    Definition Classes
    Typers
  49. trait TyperContextErrors extends AnyRef

    Definition Classes
    ContextErrors
  50. trait TyperDiagnostics extends AnyRef

    Definition Classes
    TypeDiagnostics
  51. type UnaffiliatedMacroContext = reflect.macros.runtime.Context

    Definition Classes
    StdAttachments

Value Members

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

    Definition Classes
    AnyRef
  2. final def !=(arg0: Any): Boolean

    Definition Classes
    Any
  3. final def ##(): Int

    Definition Classes
    AnyRef → Any
  4. final def ==(arg0: AnyRef): Boolean

    Definition Classes
    AnyRef
  5. final def ==(arg0: Any): Boolean

    Definition Classes
    Any
  6. final val ALTmode: Int(8192)

    ALTmode is set when we are under a pattern alternative.

    ALTmode is set when we are under a pattern alternative.

    Definition Classes
    Modes
  7. lazy val AmbiguousSearchFailure: SearchResult

    Definition Classes
    Implicits
  8. final val BYVALmode: Int(32768)

    BYVALmode is set when we are typing an expression that occurs in a by-value position.

    BYVALmode is set when we are typing an expression that occurs in a by-value position. An expression e1 is in by-value position within expression e2 iff it will be reduced to a value at that position during the evaluation of e2. Examples are by-value function arguments or the conditional of an if-then-else clause. This mode has been added to support continuations.

    Definition Classes
    Modes
  9. object CODE

    Definition Classes
    TreeDSL
  10. lazy val DivergentSearchFailure: SearchResult

    Definition Classes
    Implicits
  11. final val EXPRmode: Int(1)

    Definition Classes
    Modes
  12. object ErrorKinds extends Enumeration

    Definition Classes
    ContextErrors
  13. object ErrorUtils

    Definition Classes
    ContextErrors
  14. final val FUNmode: Int(16)

    FUNmode is orthogonal to above.

    FUNmode is orthogonal to above. When set we are looking for a method or constructor.

    Definition Classes
    Modes
  15. object Function1

    An extractor for unary function types arg => res

  16. final val HKmode: Int(16384)

    HKmode is set when we are typing a higher-kinded type.

    HKmode is set when we are typing a higher-kinded type. adapt should then check kind-arity based on the prototypical type's kind arity. Type arguments should not be inferred.

    Definition Classes
    Modes
  17. object HasMember

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

  18. object HasMethodMatching

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

  19. object ImplicitNotFoundMsg

    Definition Classes
    Implicits
  20. final val LHSmode: Int(1024)

    LHSmode is set for the left-hand side of an assignment.

    LHSmode is set for the left-hand side of an assignment.

    Definition Classes
    Modes
  21. object MacroBodyTypecheckException extends Exception with ControlThrowable with Product with Serializable

    Definition Classes
    ContextErrors
  22. final val NOmode: Int(0)

    NOmode, EXPRmode and PATTERNmode are mutually exclusive.

    NOmode, EXPRmode and PATTERNmode are mutually exclusive.

    Definition Classes
    Modes
  23. object NamesDefaultsErrorsGen

    Definition Classes
    ContextErrors
  24. object NoContext extends Analyzer.Context

    Definition Classes
    Contexts
  25. val NoImplicitInfo: ImplicitInfo

    A sentinel indicating no implicit was found

    A sentinel indicating no implicit was found

    Definition Classes
    Implicits
  26. final val PATTERNmode: Int(2)

    Definition Classes
    Modes
  27. final val POLYmode: Int(32)

    POLYmode is orthogonal to above.

    POLYmode is orthogonal to above. When set expression types can be polymorphic.

    Definition Classes
    Modes
  28. final val QUALmode: Int(64)

    QUALmode is orthogonal to above.

    QUALmode is orthogonal to above. When set expressions may be packages and Java statics modules.

    Definition Classes
    Modes
  29. final val RETmode: Int(131072)

    RETmode is set when we are typing a return expression.

    RETmode is set when we are typing a return expression.

    Definition Classes
    Modes
  30. final val SCCmode: Int(8)

    SCCmode is orthogonal to above.

    SCCmode is orthogonal to above. When set we are in the this or super constructor call of a constructor.

    Definition Classes
    Modes
  31. final val SNDTRYmode: Int(512)

    SNDTRYmode indicates that an application is typed for the 2nd time.

    SNDTRYmode indicates that an application is typed for the 2nd time. In that case functions may no longer be coerced with implicit views.

    Definition Classes
    Modes
  32. final val STARmode: Int(4096)

    STARmode is set when star patterns are allowed.

    STARmode is set when star patterns are allowed. (This was formerly called REGPATmode.)

    Definition Classes
    Modes
  33. final val SUPERCONSTRmode: Int(256)

    SUPERCONSTRmode is set for the super in a superclass constructor call super.

    SUPERCONSTRmode is set for the super in a superclass constructor call super.<init>.

    Definition Classes
    Modes
  34. lazy val SearchFailure: SearchResult

    Definition Classes
    Implicits
  35. object SymbolTracker extends Global.Traverser

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

  36. final val TAPPmode: Int(128)

    TAPPmode is set for the function/type constructor part of a type application.

    TAPPmode is set for the function/type constructor part of a type application. When set we do not decompose PolyTypes.

    Definition Classes
    Modes
  37. final val TYPEPATmode: Int(65536)

    TYPEPATmode is set when we are typing a type in a pattern.

    TYPEPATmode is set when we are typing a type in a pattern.

    Definition Classes
    Modes
  38. final val TYPEmode: Int(4)

    TYPEmode needs a comment.

    TYPEmode needs a comment. <-- XXX.

    Definition Classes
    Modes
  39. object UnTyper extends Global.Traverser

    Definition Classes
    Typers
  40. 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
  41. def actualArgs(pos: Global.Position, actuals: List[Global.Tree], nformals: Int): List[Global.Tree]

    Definition Classes
    Infer
  42. def actualTypes(actuals: List[Global.Type], nformals: Int): List[Global.Type]

    Definition Classes
    Infer
  43. def adaptAnnotations(tree: Global.Tree, typer: Typer, mode: Int, pt: Global.Type): Global.Tree

    Definition Classes
    AnalyzerPlugins
    See also

    AnalyzerPlugin.adaptAnnotations

  44. def addAnalyzerPlugin(plugin: AnalyzerPlugin): Unit

    Registers a new analyzer plugin

    Registers a new analyzer plugin

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

    Extend the argument list givenArgs with default arguments.

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

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

    Definition Classes
    NamesDefaults
  46. 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
  47. 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
  48. def alternatives(tree: Global.Tree): List[Global.Type]

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

    Definition Classes
    TypeDiagnostics
  50. final def asInstanceOf[T0]: T0

    Definition Classes
    Any
  51. def assertFn(cond: Boolean, msg: ⇒ Any): Unit

    Definition Classes
    TreeCheckers
  52. def canAdaptAnnotations(tree: Global.Tree, typer: Typer, mode: Int, pt: Global.Type): Boolean

    Definition Classes
    AnalyzerPlugins
    See also

    AnalyzerPlugin.canAdaptAnnotations

  53. 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
  54. 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
  55. 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
  56. 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
  57. 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
  58. def check(unit: Global.CompilationUnit): Unit

    Definition Classes
    TreeCheckers
  59. def checkTrees(): Unit

    Definition Classes
    TreeCheckers
  60. def clone(): AnyRef

    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  61. def companionModuleDef(cdef: Global.ClassDef, parents: List[Global.Tree] = Nil, body: List[Global.Tree] = Nil): Global.ModuleDef

    Definition Classes
    Unapplies
  62. 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
  63. def computeMacroDefTypeFromMacroImpl(macroDdef: Global.DefDef, macroImpl: Global.Symbol): Global.Type

    Definition Classes
    Macros
  64. def copyUntyped[T <: Global.Tree](tree: T): T

    Definition Classes
    Unapplies
  65. def copyUntypedInvariant(td: Global.TypeDef): Global.TypeDef

    Definition Classes
    Unapplies
  66. def decodeWithKind(name: Global.Name, owner: Global.Symbol): String

    Definition Classes
    TypeDiagnostics
  67. 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
  68. def disambiguate(ss: List[String]): collection.immutable.List[String]

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

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

    Definition Classes
    AnyRef
  71. def equals(arg0: Any): Boolean

    Definition Classes
    AnyRef → Any
  72. def errorFn(pos: Global.Position, msg: Any): Unit

    Definition Classes
    TreeCheckers
  73. def errorFn(msg: Any): Unit

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

    Expand partial function applications of type type.

    Expand partial function applications of type type.

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

    tree is already attributed

    Definition Classes
    EtaExpansion
  75. object etaExpansion

    Definition Classes
    EtaExpansion
  76. def existentialContext(tp: Global.Type): String

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

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

    Definition Classes
    TypeDiagnostics
  79. 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
  80. def extractorFormalTypes(pos: Global.Position, resTp: Global.Type, nbSubPats: Int, unappSym: Global.Symbol, effectiveNbSubPats: Int): (List[Global.Type], List[Global.Type])

    Returns (formals, formalsExpanded) where formalsExpanded are the expected types for the nbSubPats sub-patterns of an extractor pattern, of which the corresponding unapply[Seq] call is assumed to have result type resTp.

    Returns (formals, formalsExpanded) where formalsExpanded are the expected types for the nbSubPats sub-patterns of an extractor pattern, of which the corresponding unapply[Seq] call is assumed to have result type resTp.

    formals are the formal types before expanding a potential repeated parameter (must come last in formals, if at all)

    nbSubPats

    The number of arguments to the extractor pattern

    effectiveNbSubPats

    nbSubPats, unless there is one sub-pattern which, after unwrapping bind patterns, is a Tuple pattern, in which case it is the number of elements. Used to issue warnings about binding a TupleN to a single value.

    Definition Classes
    Infer
    Exceptions thrown
    TypeError

    when the unapply[Seq] definition is ill-typed

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

    The apply method corresponding to a case class

    The apply method corresponding to a case class

    Definition Classes
    Unapplies
  82. lazy val fastTrack: Map[Global.Symbol, FastTrackEntry]

    Definition Classes
    FastTrack
  83. implicit def fastTrackEntry2MacroRuntime(entry: FastTrackEntry): (MacroArgs) ⇒ Any

    Definition Classes
    FastTrack
  84. def finalize(): Unit

    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )
  85. final def forArgMode(fun: Global.Tree, mode: Int): Int

    Definition Classes
    Typers
  86. final def forFunMode(mode: Int): Int

    Definition Classes
    Modes
  87. final def forTypeMode(mode: Int): Int

    Definition Classes
    Modes
  88. def formalTypes(formals: List[Global.Type], nargs: 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 (nargs - params.length + 1) copies of its type is returned. 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 foundReqMsg(found: Global.Type, req: Global.Type): String

    Definition Classes
    TypeDiagnostics
  90. 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.

    tparam

    ...

    returns

    ...

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

    Definition Classes
    AnyRef → Any
  92. val global: Global.this.type

    Definition Classes
    treeCheckerAnalyzerTreeDSLVariances
  93. def globalSettings: Settings

    Definition Classes
    MacrosTraces
  94. 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
  95. def hashCode(): Int

    Definition Classes
    AnyRef → Any
  96. final def inAllModes(mode: Int, required: Int): Boolean

    Definition Classes
    Modes
  97. final def inAnyMode(mode: Int, required: Int): Boolean

    Definition Classes
    Modes
  98. final def inExprModeButNot(mode: Int, prohibited: Int): Boolean

    Definition Classes
    Modes
  99. final def inExprModeOr(mode: Int, others: Int): Boolean

    Definition Classes
    Modes
  100. final def inFunMode(mode: Int): Boolean

    Definition Classes
    Modes
  101. final def inHKMode(mode: Int): Boolean

    Definition Classes
    Modes
  102. final def inNoModes(mode: Int, prohibited: Int): Boolean

    Definition Classes
    Modes
  103. final def inPatternMode(mode: Int): Boolean

    Definition Classes
    Modes
  104. final def inPolyMode(mode: Int): Boolean

    Definition Classes
    Modes
  105. 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
  106. 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
  107. def inferImplicit(tree: Global.Tree, pt: Global.Type, reportAmbiguous: Boolean, isView: Boolean, context: Context, saveAmbiguousDivergent: Boolean): SearchResult

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

    Definition Classes
    Implicits
  109. def informFn(msg: Any): Unit

    Definition Classes
    TreeCheckers
  110. object instantiate extends Global.TypeMap

    Map every TypeVar to its constraint.

  111. def isIdentity(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
  112. final def isInstanceOf[T0]: Boolean

    Definition Classes
    Any
  113. def isNamed(arg: Global.Tree): Boolean

    Definition Classes
    NamesDefaults
  114. var lastAccessCheckDetails: String

    Definition Classes
    Contexts
  115. var lastTreeToTyper: Global.Tree

    Definition Classes
    Typers
  116. def linePrecedes(t1: Global.Tree, t2: Global.Tree): Boolean

    Definition Classes
    TypeDiagnostics
  117. def lockedCount: Int

    Definition Classes
    Namers
  118. lazy val macroClassloader: 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.

    Definition Classes
    Macros
  119. val macroDebugLite: Boolean

    Definition Classes
    Traces
  120. val macroDebugVerbose: Boolean

    Definition Classes
    Traces
  121. def macroExpand(typer: Typer, expandee: Global.Tree, mode: Int = EXPRmode, pt: Global.Type = WildcardType): Global.Tree

    Performs macro expansion: 1) Checks whether the expansion needs to be delayed (see mustDelayMacroExpansion) 2) Loads macro implementation using macroMirror 3) Synthesizes invocation arguments for the macro implementation 4) Checks that the result is a tree bound to this universe 5) Typechecks the result against the return type of the macro definition

    Performs macro expansion: 1) Checks whether the expansion needs to be delayed (see mustDelayMacroExpansion) 2) Loads macro implementation using macroMirror 3) Synthesizes invocation arguments for the macro implementation 4) Checks that the result is a tree bound to this universe 5) Typechecks the result against the return type of the macro definition

    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 method invocation 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
  122. 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
  123. final def macroLogLite(msg: ⇒ Any): Unit

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

    Definition Classes
    Traces
    Annotations
    @inline()
  125. 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
  126. def missingParams[T](args: List[T], params: List[Global.Symbol], argName: (T) ⇒ Option[Global.Name] = nameOf): (List[Global.Symbol], Boolean)

    Definition Classes
    NamesDefaults
  127. def mkTypeCompleter(t: Global.Tree)(c: (Global.Symbol) ⇒ Unit): TypeCompleter with LockingTypeCompleter

    Definition Classes
    Namers
  128. def modeString(mode: Int): String

    Definition Classes
    Modes
  129. def nameOf(arg: Global.Tree): Option[Global.Name]

    Definition Classes
    NamesDefaults
  130. object namerFactory extends SubComponent

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

    Definition Classes
    AnyRef
  132. def newNamer(context: Context): Namer

    Definition Classes
    Namers
  133. def newNamerFor(context: Context, tree: Global.Tree): Namer

    Definition Classes
    Namers
  134. def newTyper(context: Context): Typer

    Definition Classes
    TreeCheckersTypers
  135. val noApplyInfo: NamedApplyInfo

    Definition Classes
    NamesDefaults
  136. def noErroneousSyms(syms: Global.Symbol*): Boolean

    Definition Classes
    TypeDiagnostics
  137. def noErroneousTrees(trees: Global.Tree*): Boolean

    Definition Classes
    TypeDiagnostics
  138. def noErroneousTypes(tps: Global.Type*): Boolean

    The common situation of making sure nothing is erroneous could be nicer if Symbols, Types, and Trees all implemented some common interface in which isErroneous and similar would be placed.

    The common situation of making sure nothing is erroneous could be nicer if Symbols, Types, and Trees all implemented some common interface in which isErroneous and similar would be placed.

    Definition Classes
    TypeDiagnostics
  139. 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
  140. def notAnyRefMessage(found: Global.Type): String

    Definition Classes
    ContextErrors
  141. final def notify(): Unit

    Definition Classes
    AnyRef
  142. final def notifyAll(): Unit

    Definition Classes
    AnyRef
  143. def notifyUndetparamsAdded(newUndets: List[Global.Symbol]): Unit

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

    Definition Classes
    Macros
  145. final def onlyStickyModes(mode: Int): Int

    Definition Classes
    Modes
  146. def openMacros: collection.immutable.List[reflect.macros.runtime.Context { val universe: scala.tools.nsc.Global.treeChecker.global.type }]

    Definition Classes
    Macros
  147. object packageObjects extends SubComponent

    Definition Classes
    Analyzer
  148. def pluginsPt(pt: Global.Type, typer: Typer, tree: Global.Tree, mode: Int): Global.Type

    Definition Classes
    AnalyzerPlugins
    See also

    AnalyzerPlugin.pluginsPt

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

    Definition Classes
    AnalyzerPlugins
    See also

    AnalyzerPlugin.pluginsTypeSig

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

    Definition Classes
    AnalyzerPlugins
    See also

    AnalyzerPlugin.pluginsTypeSigAccessor

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

    Definition Classes
    AnalyzerPlugins
    See also

    AnalyzerPlugin.pluginsTyped

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

    Definition Classes
    AnalyzerPlugins
    See also

    AnalyzerPlugin.pluginsTypedReturn

  153. 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
  154. def posstr(p: Global.Position): String

    Definition Classes
    TreeCheckers
  155. def printingTypings[T](body: ⇒ T): T

    Definition Classes
    TreeCheckers
  156. 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
  157. 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
  158. 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
  159. def reorderArgsInv[T](args: List[T], pos: (Int) ⇒ Int)(implicit arg0: ClassTag[T]): List[T]

    pos

    maps indices from new to old (!)

    Definition Classes
    NamesDefaults
  160. def resetContexts(): Unit

    Definition Classes
    Contexts
  161. def resetImplicits(): Unit

    Definition Classes
    Implicits
  162. def resetTyper(): Unit

    Definition Classes
    Typers
  163. def restrictionError(pos: Global.Position, unit: Global.CompilationUnit, msg: String): Unit

    Definition Classes
    TypeDiagnostics
  164. 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
  165. def rootContext(unit: Global.CompilationUnit, tree: Global.Tree, erasedTypes: Boolean): Context

    Definition Classes
    Contexts
  166. def rootContext(unit: Global.CompilationUnit, tree: Global.Tree): Context

    Definition Classes
    Contexts
  167. def rootContext(unit: Global.CompilationUnit): Context

    Definition Classes
    Contexts
  168. 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
  169. def runWithUnit[T](unit: Global.CompilationUnit)(body: ⇒ Unit): Unit

    Definition Classes
    TreeCheckers
  170. def setAddendum(pos: Global.Position, msg: () ⇒ String): Unit

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

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

    Definition Classes
    Infer
  173. def solvedTypes(tvars: List[Global.TypeVar], tparams: List[Global.Symbol], variances: List[Int], upper: Boolean, depth: Int): 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

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

    Definition Classes
    AnyRef
  175. object synthesisUtil

    Definition Classes
    MethodSynthesis
  176. def toString(): String

    Definition Classes
    AnyRef → Any
  177. lazy val tpeOfTree: HashMap[Global.Tree, Global.Type]

    Definition Classes
    TreeCheckers
  178. def transformNamedApplication(typer: Typer, mode: Int, 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
  179. val transformed: HashMap[Global.Tree, Global.Tree]

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

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

    Definition Classes
    TypeDiagnostics
  182. 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, 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, and that that method is signature-wise compatible with the given macro definition.

    returns

    Typechecked rhs of the given macro definition if everything is okay. EmptyTree if an error occurs.

    Definition Classes
    Macros
  183. object typerFactory extends SubComponent

    Definition Classes
    Analyzer
  184. 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
  185. def unapplyMember(tp: Global.Type): Global.Symbol

    returns unapply or unapplySeq if available

    returns unapply or unapplySeq if available

    Definition Classes
    Unapplies
  186. def unapplyParameterType(extractor: Global.Symbol): Global.Symbol

    returns unapply member's parameter type.

    returns unapply member's parameter type.

    Definition Classes
    Unapplies
  187. def unapplyReturnTypeExpected(argsLength: Int): Global.Type

    returns type of the unapply method returning T_0.

    returns type of the unapply method returning T_0...T_n for n == 0, boolean for n == 1, Some[T0] else Some[Product[Ti]]

    Definition Classes
    Unapplies
  188. def unapplyTypeList(pos: Global.Position, ufn: Global.Symbol, ufntpe: Global.Type, args: List[Global.Tree]): List[Global.Type]

    returns type list for return type of the extraction

    returns type list for return type of the extraction

    Definition Classes
    Unapplies
    See also

    extractorFormalTypes

  189. 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
  190. def varianceInArgs(tps: List[Global.Type], tparams1: List[Global.Symbol])(tparam: Global.Symbol): Int

    Compute variance of type parameter tparam in all type arguments tps which correspond to formal type parameters tparams1.

    Compute variance of type parameter tparam in all type arguments tps which correspond to formal type parameters tparams1.

    Definition Classes
    Variances
  191. def varianceInAttrib(annot: Global.AnnotationInfo)(tparam: Global.Symbol): Int

    Compute variance of type parameter tparam in type annotation annot.

    Compute variance of type parameter tparam in type annotation annot.

    Definition Classes
    Variances
  192. def varianceInAttribs(annots: List[Global.AnnotationInfo])(tparam: Global.Symbol): Int

    Compute variance of type parameter tparam in all type annotations annots.

    Compute variance of type parameter tparam in all type annotations annots.

    Definition Classes
    Variances
  193. def varianceInSym(sym: Global.Symbol)(tparam: Global.Symbol): Int

    Compute variance of type parameter tparam in type of symbol sym.

    Compute variance of type parameter tparam in type of symbol sym.

    Definition Classes
    Variances
  194. def varianceInSyms(syms: List[Global.Symbol])(tparam: Global.Symbol): Int

    Compute variance of type parameter tparam in types of all symbols sym.

    Compute variance of type parameter tparam in types of all symbols sym.

    Definition Classes
    Variances
  195. def varianceInType(tp: Global.Type)(tparam: Global.Symbol): Int

    Compute variance of type parameter tparam in type tp.

    Compute variance of type parameter tparam in type tp.

    Definition Classes
    Variances
  196. def varianceInTypes(tps: List[Global.Type])(tparam: Global.Symbol): Int

    Compute variance of type parameter tparam in all types tps.

    Compute variance of type parameter tparam in all types tps.

    Definition Classes
    Variances
  197. def varianceWord(sym: Global.Symbol): String

    Definition Classes
    TypeDiagnostics
  198. final def wait(): Unit

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

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

    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  201. def withAddendum(pos: Global.Position): (String) ⇒ String

    Definition Classes
    TypeDiagnostics
  202. 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

Deprecated Value Members

  1. def companionClassOf(module: Global.Symbol, ctx: Context): Global.Symbol

    Definition Classes
    Namers
    Annotations
    @deprecated
    Deprecated

    (Since version 2.10.0) Use companionSymbolOf instead

  2. def companionModuleOf(clazz: Global.Symbol, ctx: Context): Global.Symbol

    Definition Classes
    Namers
    Annotations
    @deprecated
    Deprecated

    (Since version 2.10.0) Use companionSymbolOf instead

  3. def underlying(member: Global.Symbol): Global.Symbol

    Definition Classes
    Namers
    Annotations
    @deprecated
    Deprecated

    (Since version 2.10.0) Use underlyingSymbol instead

Inherited from TreeCheckers

Inherited from Analyzer

Inherited from AnalyzerPlugins

Inherited from StdAttachments

Inherited from ContextErrors

Inherited from TypeDiagnostics

Inherited from NamesDefaults

Inherited from Macros

Inherited from Traces

Inherited from FastTrack

Inherited from Unapplies

Inherited from SyntheticMethods

Inherited from TreeDSL

Inherited from EtaExpansion

Inherited from Variances

Inherited from Implicits

Inherited from Infer

Inherited from Checkable

Inherited from Typers

Inherited from Tags

Inherited from Adaptations

Inherited from Modes

Inherited from Namers

Inherited from MethodSynthesis

Inherited from Contexts

Inherited from AnyRef

Inherited from Any

Ungrouped