Child pages
  • Intentions
Skip to end of metadata
Go to start of metadata

You are viewing an old version of this page. View the current version.

Compare with Current View Page History

Version 1 Current »

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;
      }
    }
  }
}
  • No labels