TreeInfo

All term arguments of an application in a single flattened list

All type and value parameter symbols of this DefDef

The tree stripped of the possibly nested applications (term and type). The original tree if it's not an application.

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 tree an application with result this.type? Accept b.addOne(x) and also xs(i) += x where the op is an assignment operator.

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 term arguments of a possibly curried call

The type arguments of a possibly curried call

The underlying pattern ignoring any bindings