Intentions

Skip to end of metadata
Go to start of metadata

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)
into decimal notation. 
x = 0x30

x = 48
Convert Integer To Hex This intention converts selected integer literal (written in either decimal or octal notation)
into hexadecimal notation. 
x = 48;

x = 0x30;
Convert Integer To Octal This intention converts selected integer literal (written in either decimal or hexadecimal notation)
back into octal 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,
if possible. 
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,
if the else contains nothing but a nested 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;
      }
    }
  }
}
Labels:
None
Enter labels to add to this page:
Please wait 
Looking for a label? Just start typing.