Code intentions help you simplify your code. They are activated using Alt+Enter.
Here is a complete list of the Groovy intentions available:
Name |
Description |
Before Code |
After Code |
---|---|---|---|
Change To C Style Comment |
This intention converts one of more "end-of-line" comments to block comments. |
//comment line 1 //comment line 2 x = 0x30 |
/*comment line 1 comment line 2 */ x = 0x30 |
Change To End Of Line Comment |
This intention converts a block comment to one or more "end-of-line" comments. |
/*comment line 1 comment line 2 */ x = 0x30 |
//comment line 1 //comment line 2 x = 0x30 |
Conditional To Elvis |
This intention changes appropriate conditional operator to it's Elvis represenation. |
public class X { void f(a, b) { return a!=null?a:b } |
public class X { void f(a, b) { return a?:b } |
Convert Closure Arg To It |
This converts an implicit call to a closure into an explicit call. |
def myClosure = {i -> print i} |
def myClosure = {print it} |
Convert G String To String |
This intention converts selected GString literal into an equivalent String literal. |
x = "48" |
x = '48' |
Convert Integer To Decimal |
This intention converts selected integer literal (written in either hexadecimal or octal notation) |
x = 0x30 |
x = 48 |
Convert Integer To Hex |
This intention converts selected integer literal (written in either decimal or octal notation) |
x = 48; |
x = 0x30; |
Convert Integer To Octal |
This intention converts selected integer literal (written in either decimal or hexadecimal notation) |
x = 48; |
x = 060; |
Convert Parameter To Map Entry |
This intention converts all occurrences of selected method or closure parameters to appropriate entries of parameter map. |
def foo(arg1, arg2, arg3) { use(arg1 + arg2 + arg3) } foo("Hello ", "world", "!") |
def foo(args) { use(args.arg1 + args.arg2 + args.arg3) } foo(args1: "Hello, ", arg2: "world", arg3: "!") |
Convert String To GString |
This intention converts selected String literal into an equivalent GString literal. |
x = '48' |
x = "48" |
Demorgans Law |
This intention replaces either a || b with !(!a && !b) or a && b with !(!a || !b) inside boolean expression. |
public class X { void f(a, b) { if (!a || !b) return; } |
public class X { void f(a, b) { if (!(a && b)) return; } |
Expand Boolean |
This intention replaces uses of boolean values with equivalent if-then-else statements, |
public class X { boolean f(boolean a) { return a; } } |
public class X { boolean f(boolean a) { if(a){ return true; } else{ return false; } } } |
Flip Comparison |
This intention reverses the order of evaluation of a comparison. |
public class X { void f(a, b) { if (a < b) return; } |
public class X { void f(a, b) { if (b > a) return; } |
Flip Conditional |
This intention flips branches of the conditional operator. |
public class X { void f(a, b) { return a>b?a:b } |
public class X { void f(a, b) { return a<=b?b:a } |
Flip Conjunction |
This intention reverses the order of evaluation of an '&&' or '||' expression. |
public class X { void f(a, b) { if (a && b) return; } |
public class X { void f(a, b) { if (b &&a) return; } |
For To Each |
This intention replaces selected for..in statement with .each iterator and associated closure. |
for(x in [1, 2, 3]) { print(x) } |
[1, 2, 3].each{ x-> print(x) } |
Indexed Expression Conversion |
This intention converts access to an indexed value using "[]" to an equivalent call to a ".getAt()" or ".setAt()" method. |
x = y.getAt(z) |
x = y[z] |
Indexing Method Conversion |
This intention converts access to an indexed value using ".getAt()" or ".setAt()" methods to the equivalent [] form. |
x = y.getAt(z) |
x = y[z] |
Java Style Properties Invocation |
This intention changes Java-style properties invocation to Groovy-style. |
foo.setMyProperty(value) |
foo.myProperty = value |
Make Closure Call Explicit |
This converts an implicit call to a closure into an explicit call. |
def Closure myClosure myClosure(arg1, arg2) |
def Closure myClosure myClosure.call(arg1, arg2) |
Make Closure Call Implicit |
This converts an explicit call to a closure into an implicit call. |
def Closure myClosure myClosure.call(arg1, arg2) |
def Closure myClosure myClosure(arg1, arg2) |
Merge Else If |
This intention merges the else branch of an if-else statement, |
public class X { int f(int a) { if (a == 0) { return 0; } else { if (a == 1) { return 2; } else { return 18; } } } } |
public class X { int f(int a) { if (a == 0) { return 0; } else if (a == 1) { return 2; } else { return 18; } } } |
Merge If And |
This intention merges if-else statement inside then-branch of another if-else into one. |
public class X { void f(a, b) { if (a) if(b) return; } |
public class X { void f(a, b) { if (a &&b) return; } |
Negate Comparison |
This intention negates a comparison to it's opposite. |
public class X { void f(a, b) { if (a < b) return; } |
public class X { void f(a, b) { if (!(b >= a)) return; } |
Remove Parentheses From Method Call |
This intention convert a top level method call with parentheses to the equivalent call without parentheses. |
println("Hello World") |
println "Hello World" |
Split Else If |
This intention splits an else-if branch into an equivalent nested if statement. |
public class X { int f(int a) { if (a == 0) { return 0; } else if (a == 1) { return 2; } else { return 18; } } } |
public class X { int f(int a) { if (a == 0) { return 0; } else { if (a == 1) { return 2; } else { return 18; } } } } |