Builder (Groovy CPS Execution 1.31 API)

java.lang.Object
- com.cloudbees.groovy.cps.Builder

```
public class Builder
extends Object
```
Builder pattern for constructing Blocks into a tree. For example, to build a Block that represents "1+1", you'd call plus(one(),one())

Author:

Kohsuke Kawaguchi

Constructor Summary

Constructors
Constructor and Description

Builder(MethodLocation loc)

Constructors
Constructor and Description
`Builder(MethodLocation loc)`

Method Summary

All Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`LValueBlock`	`array(int line, Block lhs, Block index)`
`Block`	`assert_(Block cond, Block msg, String sourceText)`
`Block`	`assert_(Block cond, String sourceText)`
`Block`	`assign(int line, LValueBlock lhs, Block rhs)`
`LValueBlock`	`attribute(int line, Block lhs, Block property, boolean safe)`
`Block`	`bitwiseAnd(int line, Block lhs, Block rhs)`
`Block`	`bitwiseAndEqual(int line, LValueBlock lhs, Block rhs)`
`Block`	`bitwiseNegation(int line, Block b)`
`Block`	`bitwiseOr(int line, Block lhs, Block rhs)`
`Block`	`bitwiseOrEqual(int line, LValueBlock lhs, Block rhs)`
`Block`	`bitwiseXor(int line, Block lhs, Block rhs)`
`Block`	`bitwiseXorEqual(int line, LValueBlock lhs, Block rhs)`
`Block`	`block(Block... bodies)` {@code { ...
`Block`	`break_(String label)`
`CaseExpression`	`case_(int line, Block matcher, Block body)`
`Block`	`cast(int line, Block block, Class type, boolean coerce)` Cast to type.
`Block`	`closure(int line, List<Class> parameterTypes, List<String> parameters, Block body)`
`Block`	`compareEqual(int line, Block lhs, Block rhs)`
`Block`	`compareNotEqual(int line, Block lhs, Block rhs)`
`Block`	`compareTo(int line, Block lhs, Block rhs)`
`Block`	`constant(Object o)`
`Builder`	`contextualize(CallSiteTag... tags)` Returns a new `Builder` that contextualizes call sites with the given tags.
`Block`	`continue_(String label)`
`Block`	`declareVariable(Class type, String name)`
`Block`	`declareVariable(int line, Class type, String name, Block init)`
`Block`	`div(int line, Block lhs, Block rhs)`
`Block`	`divEqual(int line, LValueBlock lhs, Block rhs)`
`Block`	`doWhile(String label, Block body, Block cond)`
`Block`	`elvisOp(Block cond, Block falseExp)` `x ?: y`
`Block`	`false_()`
`Block`	`findRegex(int line, Block lhs, Block rhs)` `lhs =~ rhs`
`Block`	`forInLoop(int line, String label, Class type, String variable, Block collection, Block body)` {@code for (x in col) { ...
`Block`	`forLoop(String label, Block e1, Block e2, Block e3, Block body)` {@code for (e1; e2; e3) { ...
`Block`	`functionCall(int line, Block lhs, Block name, boolean safe, Block... argExps)`
`Block`	`functionCall(int line, Block lhs, String name, Block... argExps)` `LHS.name(...)`
`Block`	`greaterThan(int line, Block lhs, Block rhs)`
`Block`	`greaterThanEqual(int line, Block lhs, Block rhs)`
`Block`	`gstring(int line, Block listOfValues, Block listOfStrings)` `"Foo bar zot ${x}"` kind of string
`Block`	`if_(Block cond, Block then)`
`Block`	`if_(Block cond, Block then, Block els)` {@code if (...) { ...
`Block`	`instanceOf(int line, Block value, Block type)`
`Block`	`intdiv(int line, Block lhs, Block rhs)`
`Block`	`intdivEqual(int line, LValueBlock lhs, Block rhs)`
`Block`	`isCase(int line, Block lhs, Block rhs)` `lhs in rhs`
`Block`	`javaThis_()` See `JavaThisBlock` for the discussion of `this` vs `javaThis`
`Block`	`leftShift(int line, Block lhs, Block rhs)` `lhs << rhs`
`Block`	`leftShiftEqual(int line, LValueBlock lhs, Block rhs)` `lhs <<= rhs`
`Block`	`lessThan(int line, Block lhs, Block rhs)`
`Block`	`lessThanEqual(int line, Block lhs, Block rhs)`
`Block`	`list(Block... args)` `[a,b,c,d]` that creates a List.
`LValueBlock`	`localVariable(int line, String name)`
`LValueBlock`	`localVariable(String name)`
`Block`	`localVariableAssignOp(int line, String name, String operator, Block rhs)` Assignment operator to a local variable, such as `x += 3`
`Block`	`logicalAnd(int line, Block lhs, Block rhs)` `lhs && rhs`
`Block`	`logicalOr(int line, Block lhs, Block rhs)` `lhs \|\| rhs`
`Block`	`map(Block... blocks)` Map literal: `[ a:b, c:d, e:f ] ...` We expect arguments to be multiple of two.
`Block`	`map(List<Block> blocks)`
`Block`	`matchRegex(int line, Block lhs, Block rhs)` `lhs ==~ rhs`
`Block`	`methodPointer(int line, Block lhs, Block methodName)`
`Block`	`minus(int line, Block lhs, Block rhs)`
`Block`	`minusEqual(int line, LValueBlock lhs, Block rhs)`
`Block`	`mod(int line, Block lhs, Block rhs)`
`Block`	`modEqual(int line, LValueBlock lhs, Block rhs)`
`Block`	`multiply(int line, Block lhs, Block rhs)`
`Block`	`multiplyEqual(int line, LValueBlock lhs, Block rhs)`
`Block`	`new_(int line, Block type, Block... argExps)`
`Block`	`new_(int line, Class type, Block... argExps)` Object instantiation.
`Block`	`newArray(int line, Class type, Block... argExps)` Array instantiation like `new String[1][5]`
`Block`	`newArrayFromInitializers(Block... args)` Array with initializers like `new Object[] {1, "two"}` which exists in Java but not Groovy.
`Block`	`noop()`
`Block`	`not(int line, Block b)` `!b`
`Block`	`null_()`
`Block`	`one()`
`Block`	`plus(int line, Block lhs, Block rhs)`
`Block`	`plusEqual(int line, LValueBlock lhs, Block rhs)`
`Block`	`postfixDec(int line, LValueBlock body)` `x--`
`Block`	`postfixInc(int line, LValueBlock body)` `x++`
`Block`	`power(int line, Block lhs, Block rhs)`
`Block`	`powerEqual(int line, LValueBlock lhs, Block rhs)`
`Block`	`prefixDec(int line, LValueBlock body)` `--x`
`Block`	`prefixInc(int line, LValueBlock body)` `++x`
`LValueBlock`	`property(int line, Block lhs, Block property, boolean safe)`
`LValueBlock`	`property(int line, Block lhs, String property)`
`Block`	`range(int line, Block from, Block to, boolean inclusive)` `x..y` or `x..>y` to create a range
`Block`	`return_(Block exp)` `return exp;`
`Block`	`rightShift(int line, Block lhs, Block rhs)` `lhs >> rhs`
`Block`	`rightShiftEqual(int line, LValueBlock lhs, Block rhs)` `lhs >>= rhs`
`Block`	`rightShiftUnsigned(int line, Block lhs, Block rhs)` `lhs >>> rhs`
`Block`	`rightShiftUnsignedEqual(int line, LValueBlock lhs, Block rhs)` `lhs >>>= rhs`
`Block`	`sandboxCast(int line, Block block, Class<?> type, boolean ignoreAutoboxing, boolean strict)` Deprecated. Just for compatibility with old scripts; prefer `sandboxCastOrCoerce(int, com.cloudbees.groovy.cps.Block, java.lang.Class<?>, boolean, boolean, boolean)`
`Block`	`sandboxCastOrCoerce(int line, Block block, Class<?> type, boolean ignoreAutoboxing, boolean coerce, boolean strict)` Cast to type when `CastExpression.isCoerce()` from `SandboxCpsTransformer`.
`Block`	`sequence(Block... bodies)` Like `block(Block...)` but it doesn't create a new scope.
`Block`	`sequence(Block b)`
`Block`	`sequence(Block exp1, Block exp2)`
`Block`	`setLocalVariable(int line, String name, Block rhs)`
`Block`	`setProperty(int line, Block lhs, Block property, Block rhs)`
`Block`	`setProperty(int line, Block lhs, String property, Block rhs)`
`Block`	`staticCall(int line, Class lhs, String name, Block... argExps)`
`LValueBlock`	`staticField(int line, Class type, String name)`
`Block`	`super_(Class senderType)` Block that's only valid as a LHS of a method call like `super.foo(...)`
`Block`	`switch_(String label, Block switchExp, Block defaultStmt, CaseExpression... caseExps)`
`Block`	`ternaryOp(Block cond, Block trueExp, Block falseExp)`
`Block`	`this_()`
`Block`	`throw_(int line, Block exp)` `throw exp;`
`Block`	`true_()`
`Block`	`tryCatch(Block body, Block finally_, CatchExpression... catches)`
`Block`	`tryCatch(Block body, List<CatchExpression> catches)` {@code try { ...
`Block`	`tryCatch(Block body, List<CatchExpression> catches, Block finally_)`
`Block`	`two()`
`Block`	`unaryMinus(int line, Block lhs)`
`Block`	`unaryPlus(int line, Block lhs)`
`Block`	`while_(String label, Block cond, Block body)`
`Object`	`with(groovy.lang.Closure c)` Evaluate the given closure by passing this object as an argument.
`Builder`	`withClosureType(Class<? extends CpsClosure> t)` Overrides the actual instance type of `CpsClosure` to be created.
`Block`	`yield(Object o)`
`Block`	`zero()`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail
- Builder
```
public Builder(MethodLocation loc)
```

Method Detail

withClosureType
```
public Builder withClosureType(Class<? extends CpsClosure> t)
```
Overrides the actual instance type of CpsClosure to be created.

Returns:

'this' object for the fluent API pattern.

contextualize
```
public Builder contextualize(CallSiteTag... tags)
```
Returns a new Builder that contextualizes call sites with the given tags.

See Also:

Invoker.contextualize(CallSiteBlock)

with
```
public Object with(groovy.lang.Closure c)
```
Evaluate the given closure by passing this object as an argument. Used to bind literal Builder to a local variable.

null_
```
public Block null_()
```

noop
```
public Block noop()
```

constant
```
public Block constant(Object o)
```

methodPointer

public Block methodPointer(int line,
                           Block lhs,
                           Block methodName)

zero
```
public Block zero()
```

one
```
public Block one()
```

two
```
public Block two()
```

true_
```
public Block true_()
```

false_
```
public Block false_()
```

block
```
public Block block(Block... bodies)
```
{ ... }

sequence
```
public Block sequence(Block... bodies)
```
Like block(Block...) but it doesn't create a new scope.

sequence

public Block sequence(Block exp1,
                      Block exp2)

sequence
```
public Block sequence(Block b)
```

closure

public Block closure(int line,
                     List<Class> parameterTypes,
                     List<String> parameters,
                     Block body)

localVariable

public LValueBlock localVariable(String name)

localVariable

public LValueBlock localVariable(int line,
                                 String name)

setLocalVariable

public Block setLocalVariable(int line,
                              String name,
                              Block rhs)

declareVariable

public Block declareVariable(Class type,
                             String name)

declareVariable

public Block declareVariable(int line,
                             Class type,
                             String name,
                             Block init)

this_
```
public Block this_()
```

super_
```
public Block super_(Class senderType)
```
Block that's only valid as a LHS of a method call like super.foo(...)

javaThis_
```
public Block javaThis_()
```
See JavaThisBlock for the discussion of this vs javaThis

localVariableAssignOp

public Block localVariableAssignOp(int line,
                                   String name,
                                   String operator,
                                   Block rhs)

Assignment operator to a local variable, such as x += 3

if_

public Block if_(Block cond,
                 Block then,
                 Block els)

if (...) { ... } else { ... }

if_

public Block if_(Block cond,
                 Block then)

forLoop

public Block forLoop(String label,
                     Block e1,
                     Block e2,
                     Block e3,
                     Block body)

for (e1; e2; e3) { ... }

forInLoop

public Block forInLoop(int line,
                       String label,
                       Class type,
                       String variable,
                       Block collection,
                       Block body)

for (x in col) { ... }

break_
```
public Block break_(String label)
```

continue_
```
public Block continue_(String label)
```

while_

public Block while_(String label,
                    Block cond,
                    Block body)

doWhile

public Block doWhile(String label,
                     Block body,
                     Block cond)

tryCatch

public Block tryCatch(Block body,
                      Block finally_,
                      CatchExpression... catches)

tryCatch

public Block tryCatch(Block body,
                      List<CatchExpression> catches)


 try {
     ...
 } catch (T v) {
     ...
 } catch (T v) {
     ...
 }

tryCatch

public Block tryCatch(Block body,
                      List<CatchExpression> catches,
                      Block finally_)

throw_

public Block throw_(int line,
                    Block exp)

throw exp;

map
```
public Block map(Block... blocks)
```
Map literal: [ a:b, c:d, e:f ] ... We expect arguments to be multiple of two.

map
```
public Block map(List<Block> blocks)
```

staticCall

public Block staticCall(int line,
                        Class lhs,
                        String name,
                        Block... argExps)

plus

public Block plus(int line,
                  Block lhs,
                  Block rhs)

plusEqual

public Block plusEqual(int line,
                       LValueBlock lhs,
                       Block rhs)

minus

public Block minus(int line,
                   Block lhs,
                   Block rhs)

minusEqual

public Block minusEqual(int line,
                        LValueBlock lhs,
                        Block rhs)

multiply

public Block multiply(int line,
                      Block lhs,
                      Block rhs)

multiplyEqual

public Block multiplyEqual(int line,
                           LValueBlock lhs,
                           Block rhs)

div

public Block div(int line,
                 Block lhs,
                 Block rhs)

divEqual

public Block divEqual(int line,
                      LValueBlock lhs,
                      Block rhs)

intdiv

public Block intdiv(int line,
                    Block lhs,
                    Block rhs)

intdivEqual

public Block intdivEqual(int line,
                         LValueBlock lhs,
                         Block rhs)

mod

public Block mod(int line,
                 Block lhs,
                 Block rhs)

modEqual

public Block modEqual(int line,
                      LValueBlock lhs,
                      Block rhs)

power

public Block power(int line,
                   Block lhs,
                   Block rhs)

powerEqual

public Block powerEqual(int line,
                        LValueBlock lhs,
                        Block rhs)

unaryMinus

public Block unaryMinus(int line,
                        Block lhs)

unaryPlus

public Block unaryPlus(int line,
                       Block lhs)

ternaryOp

public Block ternaryOp(Block cond,
                       Block trueExp,
                       Block falseExp)

elvisOp

public Block elvisOp(Block cond,
                     Block falseExp)

x ?: y

compareEqual

public Block compareEqual(int line,
                          Block lhs,
                          Block rhs)

compareNotEqual

public Block compareNotEqual(int line,
                             Block lhs,
                             Block rhs)

compareTo

public Block compareTo(int line,
                       Block lhs,
                       Block rhs)

lessThan

public Block lessThan(int line,
                      Block lhs,
                      Block rhs)

lessThanEqual

public Block lessThanEqual(int line,
                           Block lhs,
                           Block rhs)

greaterThan

public Block greaterThan(int line,
                         Block lhs,
                         Block rhs)

greaterThanEqual

public Block greaterThanEqual(int line,
                              Block lhs,
                              Block rhs)

findRegex

public Block findRegex(int line,
                       Block lhs,
                       Block rhs)

lhs =~ rhs

matchRegex

public Block matchRegex(int line,
                        Block lhs,
                        Block rhs)

lhs ==~ rhs

isCase

public Block isCase(int line,
                    Block lhs,
                    Block rhs)

lhs in rhs

logicalAnd

public Block logicalAnd(int line,
                        Block lhs,
                        Block rhs)

lhs && rhs

logicalOr

public Block logicalOr(int line,
                       Block lhs,
                       Block rhs)

lhs || rhs

leftShift

public Block leftShift(int line,
                       Block lhs,
                       Block rhs)

lhs << rhs

leftShiftEqual

public Block leftShiftEqual(int line,
                            LValueBlock lhs,
                            Block rhs)

lhs <<= rhs

rightShift

public Block rightShift(int line,
                        Block lhs,
                        Block rhs)

lhs >> rhs

rightShiftEqual

public Block rightShiftEqual(int line,
                             LValueBlock lhs,
                             Block rhs)

lhs >>= rhs

rightShiftUnsigned

public Block rightShiftUnsigned(int line,
                                Block lhs,
                                Block rhs)

lhs >>> rhs

rightShiftUnsignedEqual

public Block rightShiftUnsignedEqual(int line,
                                     LValueBlock lhs,
                                     Block rhs)

lhs >>>= rhs

not

public Block not(int line,
                 Block b)

!b

bitwiseAnd

public Block bitwiseAnd(int line,
                        Block lhs,
                        Block rhs)

bitwiseAndEqual

public Block bitwiseAndEqual(int line,
                             LValueBlock lhs,
                             Block rhs)

bitwiseOr

public Block bitwiseOr(int line,
                       Block lhs,
                       Block rhs)

bitwiseOrEqual

public Block bitwiseOrEqual(int line,
                            LValueBlock lhs,
                            Block rhs)

bitwiseXor

public Block bitwiseXor(int line,
                        Block lhs,
                        Block rhs)

bitwiseXorEqual

public Block bitwiseXorEqual(int line,
                             LValueBlock lhs,
                             Block rhs)

bitwiseNegation

public Block bitwiseNegation(int line,
                             Block b)

prefixInc

public Block prefixInc(int line,
                       LValueBlock body)

++x

prefixDec

public Block prefixDec(int line,
                       LValueBlock body)

--x

postfixInc

public Block postfixInc(int line,
                        LValueBlock body)

x++

postfixDec

public Block postfixDec(int line,
                        LValueBlock body)

x--

cast

public Block cast(int line,
                  Block block,
                  Class type,
                  boolean coerce)

Cast to type.

Parameters:: coerce - True for exp as type cast. false for (type)exp cast.

sandboxCast

@Deprecated
public Block sandboxCast(int line,
                                     Block block,
                                     Class<?> type,
                                     boolean ignoreAutoboxing,
                                     boolean strict)

Deprecated. Just for compatibility with old scripts; prefer sandboxCastOrCoerce(int, com.cloudbees.groovy.cps.Block, java.lang.Class<?>, boolean, boolean, boolean)

sandboxCastOrCoerce

public Block sandboxCastOrCoerce(int line,
                                 Block block,
                                 Class<?> type,
                                 boolean ignoreAutoboxing,
                                 boolean coerce,
                                 boolean strict)

Cast to type when CastExpression.isCoerce() from SandboxCpsTransformer.

instanceOf

public Block instanceOf(int line,
                        Block value,
                        Block type)

functionCall

public Block functionCall(int line,
                          Block lhs,
                          String name,
                          Block... argExps)

LHS.name(...)

functionCall

public Block functionCall(int line,
                          Block lhs,
                          Block name,
                          boolean safe,
                          Block... argExps)

assign

public Block assign(int line,
                    LValueBlock lhs,
                    Block rhs)

property

public LValueBlock property(int line,
                            Block lhs,
                            String property)

property

public LValueBlock property(int line,
                            Block lhs,
                            Block property,
                            boolean safe)

array

public LValueBlock array(int line,
                         Block lhs,
                         Block index)

attribute

public LValueBlock attribute(int line,
                             Block lhs,
                             Block property,
                             boolean safe)

staticField

public LValueBlock staticField(int line,
                               Class type,
                               String name)

setProperty

public Block setProperty(int line,
                         Block lhs,
                         String property,
                         Block rhs)

setProperty

public Block setProperty(int line,
                         Block lhs,
                         Block property,
                         Block rhs)

new_

public Block new_(int line,
                  Class type,
                  Block... argExps)

Object instantiation.

new_

public Block new_(int line,
                  Block type,
                  Block... argExps)

newArray

public Block newArray(int line,
                      Class type,
                      Block... argExps)

Array instantiation like new String[1][5]

newArrayFromInitializers
```
public Block newArrayFromInitializers(Block... args)
```
Array with initializers like new Object[] {1, "two"} which exists in Java but not Groovy. Only used by CpsDefaultGroovyMethods and friends.

return_
```
public Block return_(Block exp)
```
return exp;

list
```
public Block list(Block... args)
```
[a,b,c,d] that creates a List.

range

public Block range(int line,
                   Block from,
                   Block to,
                   boolean inclusive)

x..y or x..>y to create a range

assert_

public Block assert_(Block cond,
                     Block msg,
                     String sourceText)

assert_

public Block assert_(Block cond,
                     String sourceText)

gstring

public Block gstring(int line,
                     Block listOfValues,
                     Block listOfStrings)

"Foo bar zot ${x}" kind of string

switch_

public Block switch_(String label,
                     Block switchExp,
                     Block defaultStmt,
                     CaseExpression... caseExps)

See Also:: case_(int, Block, Block)

case_

public CaseExpression case_(int line,
                            Block matcher,
                            Block body)

yield
```
public Block yield(Object o)
```

Class Builder

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

Builder

Method Detail

withClosureType

contextualize

with

null_

noop

constant

methodPointer

zero

one

two

true_

false_

block

sequence

sequence

sequence

closure

localVariable

localVariable

setLocalVariable

declareVariable

declareVariable

this_

super_

javaThis_

localVariableAssignOp

if_

if_

forLoop

forInLoop

break_

continue_

while_

doWhile

tryCatch

tryCatch

tryCatch

throw_

map

map

staticCall

plus

plusEqual

minus

minusEqual

multiply

multiplyEqual

div

divEqual

intdiv

intdivEqual

mod

modEqual

power

powerEqual

unaryMinus

unaryPlus

ternaryOp

elvisOp

compareEqual

compareNotEqual

compareTo

lessThan

lessThanEqual

greaterThan

greaterThanEqual

findRegex

matchRegex

isCase

logicalAnd

logicalOr

leftShift

leftShiftEqual