Some of the following predicates make use of predicate arguments. Predicate arguments are related to predicate parameters in a similar way as arguments of method invocation expressions are related to method parameters. However, there is an important difference:

Note that fields cannot be addressed by a single identifier in predicate arguments: Single identifiers as predicate arguments are always interpreted as local variables. If such a variable does not yet exist, it is declared. In order to use a field for a predicate argument expression, it can be enclosed in parentheses, or it can be qualified as in the following example:

int f;                // field declaration

void test() [
    X(f) ::> {}       // attention: implicit declaration of query variable f
    X((f)) ::> {}     // field access expression for f is used
    X(this.f) ::> {}  // field access expression for f is used
]

Some of the following predicates may have label arguments as their predicate arguments (Section 17.4.1, “Predicate Arguments”). A label argument is defined by a single identifier. A query variable is declared whose name is this identifier, this variable is then used as the label of the place of the corresponding predicate parameter.

A name predicate consists of a single name and may denote a local variable, a field, a type, a predicate, or a method. The meaning is resolved as follows:

A parametrized predicate is specified by a name and a number of arguments. Each argument may by a predicate argument (Section 17.4.1, “Predicate Arguments”), or it may be empty, which is represented by a single dot or even by omitting it at all (the latter is possibly only if there are at least two arguments, i.e., at least one comma). An empty argument is handled as a label argument (Section 17.4.2, “Label Arguments”) with an internal, compiler-generated identifier. Examples for parametrized predicates are:

F(x)
M(.)
X(a,,,d,)
Object(x)
root(n)

The meaning of the name is determined as described in Section 9.2, “Determining the Meaning of a Name”, where the possible meanings are predicate names, type names if there exists exactly one argument, and method names if there are no empty arguments. If the name is a predicate name, the parametrized predicate is reclassified as a class predicate (Section 17.4.9, “Class Predicates”) with the specified arguments. If the name is a type name, the parametrized predicate is reclassified as a wrapped type predicate (Section 17.4.6, “Wrapped Type Predicates”) with the specified argument. If the name is a method name, the parametrized predicate is reclassified as a method predicate (Section 17.4.8, “Method Predicates”) with the specified arguments.

A type predicate is specified by a single type. A type predicate may also result from the reclassification of a name predicate (Section 17.4.3, “Name Predicates”). Examples are:

Object
Runnable
long
String[]
javax.swing.tree.TreeNode

A type predicate has a single closed in-out-parameter of the specified type. It is fulfilled for every binding of values to query variables; it just serves to restrict the type of its associated query variable.

Wrapped type predicates are used to identify wrapper nodes which wrap values of other (non-node-) types. A wrapped type predicate is specified by a single type T and an argument enclosed in parentheses. A wrapped type predicate may also result from the reclassification of a parametrized predicate (Section 17.4.4, “Parametrized Predicates”). Examples are:

String[](a)
int(i)

A wrapped type predicate has two parameters: The first is its closed in-out-parameter, its type is the result of the method invocation getWrapperClassFor(T) on the current compile-time model (Section 3.1, “Compile-Time Model”). The second parameter has type T. A wrapped type predicate is fulfilled if and only if the result of the invocation of the method isWrapperFor(o, T) on the current run-time model (Section 3.2, “Run-Time Model”) returns true, where o is the bound value of the first parameter, and if in addition the result of the invocation of the method unwrapA(o) on the current run-time model is equal in the sense of the operator == to the bound value of the second parameter. A is the type affix (Section 6.1, “Type Affixes and Type Letters”) of T.

Expression predicates are used to directly fix the value of a query variable to the result of an expression. If necessary, the expression has to be enclosed in backslash-prefixed parentheses; the backslash is needed in order to disambiguate the syntax. An expression predicate may also result from the reclassification of a name predicate (Section 17.4.3, “Name Predicates”), a method predicate (Section 17.4.8, “Method Predicates”), or a root predicate (Section 17.4.10, “Root Predicate”). Examples are:

this
"Hello World"
42
\(a[i])
\(x + y)

An expression predicate has a single closed in-out-parameter of the type of the expression. It is fulfilled iff the bound value of the parameter is equal in the sense of the operator == to the result of the evaluation of the expression.

Method predicates are used to create predicates from methods. At first, the tokens to the left from the last '.' are treated as an ordinary expression. Then the most specific applicable (Chapter 13, Signatures) and accessible method declared in or inherited by the type of the expression is chosen, where the set of possible argument transformations (Section 13.1, “Argument Transformations”) is:

Method predicates may also result from the reclassification of a name predicate (Section 17.4.3, “Name Predicates”) or a parametrized predicate (Section 17.4.4, “Parametrized Predicates”), in these cases they consist of a name and an argument list. The name is resolved as for method invocation expressions, and the predicate is handled as before.

Examples for method predicates are:

getRoot()
x.getParent()
isVisible()

A class predicate results from the reclassification of a name predicate (Section 17.4.3, “Name Predicates”) or a parametrized predicate (Section 17.4.4, “Parametrized Predicates”). The reclassification provides a predicate name and a list of arguments for the class predicate. Now the most specific class predicate (Chapter 12, Class Predicates) is determined as specified for signatures (Chapter 13, Signatures), and the parameters of the resulting class predicate declaration are the parameters of the predicate. The following alternatives of argument transformations (Section 13.1, “Argument Transformations”) are possible:

Label arguments (Section 17.4.2, “Label Arguments”) are always commensurate with their parameter. Note that for class predicates, parameters and arguments of reference type are commensurate if there exists a casting conversion (Section 13.2, “Applicable Signatures”).

As a class predicate is declared by a subclass of de.grogra.xl.qnp.ClassPredicate (Chapter 12, Class Predicates), its class has to implement the abstract method createMatcher. The returned instance of de.grogra.xl.qnp.Predicate.Matcher defines a means to fulfill the class predicate.

A root predicate is used to bind a query variable to the root node of the extent (Section 3.2, “Run-Time Model”) of the current query state qs (Section 17.2, “Invocation of Queries”). It is reclassified as an expression predicate (Section 17.4.7, “Expression Predicates”), its expression being qs.getExtent().getRoot().