diff --git a/plugins/IntentionPowerPak/src/com/siyeh/ipp/trivialif/ExpandBooleanIntention.java b/plugins/IntentionPowerPak/src/com/siyeh/ipp/trivialif/ExpandBooleanIntention.java
index 7f3a64f8d5ee..5985b5775b3f 100644
--- a/plugins/IntentionPowerPak/src/com/siyeh/ipp/trivialif/ExpandBooleanIntention.java
+++ b/plugins/IntentionPowerPak/src/com/siyeh/ipp/trivialif/ExpandBooleanIntention.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2003-2010 Dave Griffith, Bas Leijdekkers
+ * Copyright 2003-2012 Dave Griffith, Bas Leijdekkers
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -33,25 +33,20 @@ public class ExpandBooleanIntention extends Intention {
   }
 
   @Override
-  public void processIntention(@NotNull PsiElement element)
-    throws IncorrectOperationException {
-    final PsiStatement containingStatement =
-      PsiTreeUtil.getParentOfType(element, PsiStatement.class);
+  public void processIntention(@NotNull PsiElement element) throws IncorrectOperationException {
+    final PsiStatement containingStatement = PsiTreeUtil.getParentOfType(element, PsiStatement.class);
     if (containingStatement == null) {
       return;
     }
     if (ExpandBooleanPredicate.isBooleanAssignment(containingStatement)) {
-      final PsiExpressionStatement assignmentStatement =
-        (PsiExpressionStatement)containingStatement;
-      final PsiAssignmentExpression assignmentExpression =
-        (PsiAssignmentExpression)assignmentStatement.getExpression();
+      final PsiExpressionStatement assignmentStatement = (PsiExpressionStatement)containingStatement;
+      final PsiAssignmentExpression assignmentExpression = (PsiAssignmentExpression)assignmentStatement.getExpression();
       final PsiExpression rhs = assignmentExpression.getRExpression();
       if (rhs == null) {
         return;
       }
       final PsiExpression lhs = assignmentExpression.getLExpression();
-      if (ErrorUtil.containsDeepError(lhs) ||
-          ErrorUtil.containsDeepError(rhs)) {
+      if (ErrorUtil.containsDeepError(lhs) || ErrorUtil.containsDeepError(rhs)) {
         return;
       }
       final String rhsText = rhs.getText();
@@ -65,16 +60,11 @@ public class ExpandBooleanIntention extends Intention {
       else {
         conditionText = rhsText;
       }
-
-      @NonNls final String statement =
-        "if(" + conditionText + ") " + lhsText + " = true; else " +
-        lhsText + " = false;";
+      @NonNls final String statement = "if(" + conditionText + ") " + lhsText + " = true; else " + lhsText + " = false;";
       replaceStatement(statement, containingStatement);
     }
-    else if (ExpandBooleanPredicate.isBooleanReturn(
-      containingStatement)) {
-      final PsiReturnStatement returnStatement =
-        (PsiReturnStatement)containingStatement;
+    else if (ExpandBooleanPredicate.isBooleanReturn(containingStatement)) {
+      final PsiReturnStatement returnStatement = (PsiReturnStatement)containingStatement;
       final PsiExpression returnValue = returnStatement.getReturnValue();
       if (returnValue == null) {
         return;
@@ -83,9 +73,26 @@ public class ExpandBooleanIntention extends Intention {
         return;
       }
       final String valueText = returnValue.getText();
-      @NonNls final String statement =
-        "if(" + valueText + ") return true; else return false;";
+      @NonNls final String statement = "if(" + valueText + ") return true; else return false;";
       replaceStatement(statement, containingStatement);
     }
+    else if (ExpandBooleanPredicate.isBooleanDeclaration(containingStatement)) {
+      final PsiDeclarationStatement declarationStatement = (PsiDeclarationStatement)containingStatement;
+      final PsiElement declaredElement = declarationStatement.getDeclaredElements()[0];
+      if (!(declaredElement instanceof PsiLocalVariable)) {
+        return;
+      }
+      final PsiLocalVariable variable = (PsiLocalVariable)declaredElement;
+      final PsiExpression initializer = variable.getInitializer();
+      if (initializer == null) {
+        return;
+      }
+      final String name = variable.getName();
+      @NonNls final String newStatementText = "if(" + initializer.getText() + ") " + name +"=true; else " + name + "=false;";
+      final PsiElementFactory factory = JavaPsiFacade.getElementFactory(containingStatement.getProject());
+      final PsiStatement newStatement = factory.createStatementFromText(newStatementText, containingStatement);
+      declarationStatement.getParent().addAfter(newStatement, declarationStatement);
+      initializer.delete();
+    }
   }
 }
\ No newline at end of file
diff --git a/plugins/IntentionPowerPak/src/com/siyeh/ipp/trivialif/ExpandBooleanPredicate.java b/plugins/IntentionPowerPak/src/com/siyeh/ipp/trivialif/ExpandBooleanPredicate.java
index 9696c87199e5..63ee78443010 100644
--- a/plugins/IntentionPowerPak/src/com/siyeh/ipp/trivialif/ExpandBooleanPredicate.java
+++ b/plugins/IntentionPowerPak/src/com/siyeh/ipp/trivialif/ExpandBooleanPredicate.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2003-2010 Dave Griffith, Bas Leijdekkers
+ * Copyright 2003-2012 Dave Griffith, Bas Leijdekkers
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -18,7 +18,6 @@ package com.siyeh.ipp.trivialif;
 import com.intellij.psi.*;
 import com.intellij.psi.util.PsiTreeUtil;
 import com.siyeh.ipp.base.PsiElementPredicate;
-import com.siyeh.ipp.psiutils.ErrorUtil;
 
 class ExpandBooleanPredicate implements PsiElementPredicate {
 
@@ -26,53 +25,63 @@ class ExpandBooleanPredicate implements PsiElementPredicate {
     if (!(element instanceof PsiJavaToken)) {
       return false;
     }
-    final PsiStatement containingStatement =
-      PsiTreeUtil.getParentOfType(element,
-                                  PsiStatement.class);
+    final PsiStatement containingStatement = PsiTreeUtil.getParentOfType(element, PsiStatement.class);
     if (containingStatement == null) {
       return false;
     }
-    return isBooleanReturn(containingStatement) ||
-           isBooleanAssignment(containingStatement);
+    return isBooleanReturn(containingStatement) || isBooleanAssignment(containingStatement) || isBooleanDeclaration(containingStatement);
   }
 
-  public static boolean isBooleanReturn(PsiStatement containingStatement) {
-    if (!(containingStatement instanceof PsiReturnStatement)) {
+  public static boolean isBooleanReturn(PsiStatement statement) {
+    if (!(statement instanceof PsiReturnStatement)) {
       return false;
     }
-    final PsiReturnStatement returnStatement =
-      (PsiReturnStatement)containingStatement;
+    final PsiReturnStatement returnStatement = (PsiReturnStatement)statement;
     final PsiExpression returnValue = returnStatement.getReturnValue();
     if (returnValue == null || returnValue instanceof PsiLiteralExpression) {
       return false;
     }
     final PsiType returnType = returnValue.getType();
-    if (!PsiType.BOOLEAN.equals(returnType)) {
-      return false;
-    }
-    return !ErrorUtil.containsError(returnValue);
+    return PsiType.BOOLEAN.equals(returnType);
   }
 
-  public static boolean isBooleanAssignment(PsiStatement containingStatement) {
-    if (!(containingStatement instanceof PsiExpressionStatement)) {
+  public static boolean isBooleanAssignment(PsiStatement statement) {
+    if (!(statement instanceof PsiExpressionStatement)) {
       return false;
     }
-    final PsiExpressionStatement expressionStatement =
-      (PsiExpressionStatement)containingStatement;
+    final PsiExpressionStatement expressionStatement = (PsiExpressionStatement)statement;
     final PsiExpression expression = expressionStatement.getExpression();
     if (!(expression instanceof PsiAssignmentExpression)) {
       return false;
     }
-    final PsiAssignmentExpression assignment =
-      (PsiAssignmentExpression)expression;
+    final PsiAssignmentExpression assignment = (PsiAssignmentExpression)expression;
     final PsiExpression rhs = assignment.getRExpression();
     if (rhs == null || rhs instanceof PsiLiteralExpression) {
       return false;
     }
     final PsiType assignmentType = rhs.getType();
-    if (!PsiType.BOOLEAN.equals(assignmentType)) {
+    return PsiType.BOOLEAN.equals(assignmentType);
+  }
+
+  public static boolean isBooleanDeclaration(PsiStatement statement) {
+    if (!(statement instanceof PsiDeclarationStatement)) {
       return false;
     }
-    return !ErrorUtil.containsError(rhs);
+    final PsiDeclarationStatement declarationStatement = (PsiDeclarationStatement)statement;
+    final PsiElement[] declaredElements = declarationStatement.getDeclaredElements();
+    if (declaredElements.length != 1) {
+      return false;
+    }
+    final PsiElement element = declaredElements[0];
+    if (!(element instanceof PsiLocalVariable)) {
+      return false;
+    }
+    final PsiLocalVariable variable = (PsiLocalVariable)element;
+    final PsiExpression initializer = variable.getInitializer();
+    if (initializer == null || initializer instanceof PsiLiteralExpression) {
+      return false;
+    }
+    final PsiType type = initializer.getType();
+    return PsiType.BOOLEAN.equals(type);
   }
 }