UntypedTreeInfo

An extractor for trees of the form id or id: T

Under pureFunctions: A builder and extractor for => T, which is an alias for {*}-> T. Only trees of the form => T are matched; trees written directly as {*}-> T are ignored by the extractor.

Info of a variable in a pattern: The named tree and its type

The largest subset of {NoInits, PureInterface} that a trait or class with this body can have as flags.

Is tree an context function or closure, possibly nested in a block?

The underlying tree when stripping any TypedSplice or Parens nodes

All term arguments of an application in a single flattened list

All type and value parameter symbols of this DefDef

Does this CaseDef catch everything of a certain Type?

Does this CaseDef catch Throwable?

The first constructor definition in stats

Checks whether predicate p is true for all result parts of this expression, where we zoom into Ifs, Matches, and Blocks.

Is tree explicitly parameterized with type arguments?

Does this list contain a named argument tree?

Is tree a backquoted identifier or definition

Is tree a type tree of the form => T or (under pureFunctions) {refs}-> T?

Is this pattern node a catch-all (wildcard or variable) pattern?

Is this case guarded?

Is tree a path?

Is tpt a vararg type of the form T* or => T*?

Is tree a self constructor call this(...)? I.e. a call to a constructor of the same object?

Is tree a super constructor call?

Is this parameter list a using clause?

Is tree a variable pattern?

Is the argument a wildcard argument of the form _ or x @ _?

Is this argument node of the form *, or is it a reference to such an argument ? The latter case can happen when an argument is lifted.

Does this argument list end with an argument of the form : _* ?

If path looks like a language import, Some(name) where name is experimental if that sub-module is imported, and the empty term name otherwise.

The method part of an application node, possibly enclosed in a block with only valdefs as statements. the reason for also considering blocks is that named arguments can transform a call into a block, e.g. (b = foo, a = bar) is transformed to { val x$1 = foo val x$2 = bar (x$2, x$1) }

The number of arguments in an application

The largest subset of {NoInits, PureInterface} that a trait or class with these parents can have as flags.

If this is an application, its function part, stripping all Apply nodes (but leaving TypeApply nodes in). Otherwise the tree itself.

If this is a block, its expression part

Strip => T to T and (under pureFunctions) {refs}-> T to T

The underlying pattern ignoring any bindings