path: root/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/psiutils/DefiniteAssignmentUtil.java

/*
 * Copyright 2000-2014 JetBrains s.r.o.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.siyeh.ig.psiutils;

import com.intellij.psi.*;
import com.intellij.psi.tree.IElementType;
import com.intellij.psi.util.PsiUtil;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;

/**
 * Implementation of Java Language Specification, Chapter 16. Definite Assignment
 * with some changes to match javac behavior where it does not match the specification.
 * @author Bas Leijdekkers
 */
public final class DefiniteAssignmentUtil {

  public static void checkVariable(PsiVariable variable, DefiniteAssignment definiteAssignment) {
    if (variable instanceof PsiField) {
      final PsiField field = (PsiField)variable;
      checkField(field, definiteAssignment);
    }
  }

  private static void checkField(PsiField field, DefiniteAssignment definiteAssignment) {
    if (field.getInitializer() != null) {
      definiteAssignment.set(true, false);
    }
    final PsiClass aClass = field.getContainingClass();
    if (aClass == null) {
      return;
    }
    final PsiElement[] children = aClass.getChildren();
    if (field.hasModifierProperty(PsiModifier.STATIC)) {
      for (PsiElement child : children) {
        if (child instanceof PsiField) {
          final PsiField otherField = (PsiField)child;
          if (!otherField.hasModifierProperty(PsiModifier.STATIC)) {
            continue;
          }
          checkExpression(otherField.getInitializer(), definiteAssignment, BooleanExpressionValue.UNDEFINED);
        }
        else if (child instanceof PsiClassInitializer) {
          final PsiClassInitializer classInitializer = (PsiClassInitializer)child;
          if (!classInitializer.hasModifierProperty(PsiModifier.STATIC)) {
            continue;
          }
          checkCodeBlock(classInitializer.getBody(), definiteAssignment);
        }
      }
    }
    else {
      for (PsiElement child : children) {
        if (child instanceof PsiField) {
          final PsiField otherField = (PsiField)child;
          if (otherField.hasModifierProperty(PsiModifier.STATIC)) {
            continue;
          }
          checkExpression(otherField.getInitializer(), definiteAssignment, BooleanExpressionValue.UNDEFINED);
        }
        else if (child instanceof PsiClassInitializer) {
          final PsiClassInitializer classInitializer = (PsiClassInitializer)child;
          if (classInitializer.hasModifierProperty(PsiModifier.STATIC)) {
            continue;
          }
          checkCodeBlock(classInitializer.getBody(), definiteAssignment);
        }
        if (definiteAssignment.stop()) return;
      }
      final PsiMethod[] constructors = aClass.getConstructors();
      if (constructors.length != 0) { // missing from spec?
        final boolean da = definiteAssignment.isDefinitelyAssigned();
        final boolean du = definiteAssignment.isDefinitelyUnassigned();
        boolean resultDa = true;
        boolean resultDu = true;
        for (PsiMethod constructor : constructors) {
          checkConstructor(constructor, definiteAssignment);
          resultDa &= definiteAssignment.isDefinitelyAssigned();
          resultDu &= definiteAssignment.isDefinitelyUnassigned();
          if (definiteAssignment.stop()) return;
          definiteAssignment.set(da, du);
        }
        definiteAssignment.set(resultDa, resultDu);
      }
    }
  }

  private static boolean isAlternateConstructorInvocation(PsiStatement statement) {
    return isConstructorInvocation(statement, PsiKeyword.THIS);
  }

  private static boolean isSuperClassConstructorInvocation(PsiStatement statement) {
    return isConstructorInvocation(statement, PsiKeyword.SUPER);
  }

  private static boolean isConstructorInvocation(PsiStatement statement, @NotNull String keyword) {
    if (!(statement instanceof PsiExpressionStatement)) {
      return false;
    }
    final PsiExpressionStatement expressionStatement = (PsiExpressionStatement)statement;
    final PsiExpression expression = expressionStatement.getExpression();
    if (!(expression instanceof PsiMethodCallExpression)) {
      return false;
    }
    final PsiMethodCallExpression methodCallExpression = (PsiMethodCallExpression)expression;
    final PsiReferenceExpression methodExpression = methodCallExpression.getMethodExpression();
    return keyword.equals(methodExpression.getReferenceName());
  }

  private static void checkAnonymousClass(PsiAnonymousClass anonymousClass, DefiniteAssignment definiteAssignment) {
    for (PsiField field : anonymousClass.getFields()) {
      checkExpression(field.getInitializer(), definiteAssignment, BooleanExpressionValue.UNDEFINED);
    }
    final PsiClassInitializer[] initializers = anonymousClass.getInitializers();
    for (PsiClassInitializer initializer : initializers) {
      checkCodeBlock(initializer.getBody(), definiteAssignment);
    }
    final boolean da = definiteAssignment.isDefinitelyAssigned();
    final boolean du = definiteAssignment.isDefinitelyUnassigned();
    for (PsiMethod method : anonymousClass.getMethods()) {
      definiteAssignment.set(true, false);
      checkCodeBlock(method.getBody(), definiteAssignment);
    }
    definiteAssignment.set(da, du);
  }

  private static void checkClass(PsiClass aClass, DefiniteAssignment definiteAssignment) {
    for (PsiField field : aClass.getFields()) {
      checkExpression(field.getInitializer(), definiteAssignment, BooleanExpressionValue.UNDEFINED);
    }
    for (PsiClassInitializer initializer : aClass.getInitializers()) {
      checkCodeBlock(initializer.getBody(), definiteAssignment);
    }
    for (PsiMethod method : aClass.getMethods()) {
      checkCodeBlock(method.getBody(), definiteAssignment);
    }
    for (PsiClass innerClass : aClass.getInnerClasses()) {
      checkClass(innerClass, definiteAssignment);
    }
  }

  private static void checkConstructor(PsiMethod constructor, DefiniteAssignment definiteAssignment) {
    final boolean da = definiteAssignment.isDefinitelyAssigned();
    final boolean du = definiteAssignment.isDefinitelyUnassigned();
    definiteAssignment.set(false, true);
    final PsiCodeBlock body = constructor.getBody();
    if (body == null) {
      return;
    }
    final PsiStatement[] statements = body.getStatements();
    boolean superCalled = false;
    for (int i = 0; i < statements.length; i++) {
      final PsiStatement statement = statements[i];
      if (i == 0) {
        if (isAlternateConstructorInvocation(statement)) {
          checkStatement(statement, definiteAssignment);
          definiteAssignment.set(true, false);
          superCalled = true;
          continue;
        }
        else if (isSuperClassConstructorInvocation(statement)) {
          checkStatement(statement, definiteAssignment);
          definiteAssignment.set(da, du);
          superCalled = true;
          continue;
        }
      }
      if (!superCalled) {
        // implicit super call
        definiteAssignment.set(da, du);
        superCalled = true;
      }
      checkStatement(statement,definiteAssignment);
    }
    if (!superCalled) {
      // constructor has no statements
      definiteAssignment.set(da, du);
    }
    definiteAssignment.andDefiniteAssignmentBeforeReturn(constructor); // missing from spec?
  }

  private static void checkCodeBlock(@Nullable PsiCodeBlock codeBlock, DefiniteAssignment definiteAssignment) {
    if (codeBlock == null) {
      return;
    }
    for (PsiStatement statement : codeBlock.getStatements()) {
      checkStatement(statement, definiteAssignment);
    }
  }

  private static void checkLocalVariable(PsiLocalVariable localVariable, DefiniteAssignment definiteAssignment) {
    final PsiExpression initializer = localVariable.getInitializer();
    if (initializer != null && definiteAssignment.getVariable() == localVariable) {
      definiteAssignment.set(true, false);
    }
    checkExpression(initializer, definiteAssignment, BooleanExpressionValue.UNDEFINED);
  }

  private static void checkStatement(@Nullable PsiStatement statement, DefiniteAssignment definiteAssignment) {
    if (statement == null || definiteAssignment.stop() || statement instanceof PsiEmptyStatement) {
      return;
    }
    if (statement instanceof PsiAssertStatement) {
      final PsiAssertStatement assertStatement = (PsiAssertStatement)statement;
      checkAssertStatement(assertStatement, definiteAssignment);
    }
    else if (statement instanceof PsiBlockStatement) {
      final PsiBlockStatement blockStatement = (PsiBlockStatement)statement;
      checkCodeBlock(blockStatement.getCodeBlock(), definiteAssignment);
    }
    else if (statement instanceof PsiBreakStatement) {
      final PsiBreakStatement breakStatement = (PsiBreakStatement)statement;
      checkBreakStatement(breakStatement, definiteAssignment);
    }
    else if (statement instanceof PsiContinueStatement) {
      final PsiContinueStatement continueStatement = (PsiContinueStatement)statement;
      checkContinueStatement(continueStatement, definiteAssignment);
    }
    else if (statement instanceof PsiDeclarationStatement) {
      final PsiDeclarationStatement declarationStatement = (PsiDeclarationStatement)statement;
      checkDeclarationStatement(declarationStatement, definiteAssignment);
    }
    else if (statement instanceof PsiDoWhileStatement) {
      final PsiDoWhileStatement doWhileStatement = (PsiDoWhileStatement)statement;
      checkDoWhileStatement(doWhileStatement, definiteAssignment);
    }
    else if (statement instanceof PsiExpressionStatement) {
      final PsiExpressionStatement expressionStatement = (PsiExpressionStatement)statement;
      checkExpression(expressionStatement.getExpression(), definiteAssignment, BooleanExpressionValue.UNDEFINED);
    }
    else if (statement instanceof PsiExpressionListStatement) {
      final PsiExpressionListStatement expressionListStatement = (PsiExpressionListStatement)statement;
      checkExpressionListStatement(expressionListStatement, definiteAssignment);
    }
    else if (statement instanceof PsiForeachStatement) {
      final PsiForeachStatement foreachStatement = (PsiForeachStatement)statement;
      checkForeachStatement(foreachStatement, definiteAssignment);
    }
    else if (statement instanceof PsiForStatement) {
      final PsiForStatement forStatement = (PsiForStatement)statement;
      checkForStatement(forStatement, definiteAssignment);
    }
    else if (statement instanceof PsiIfStatement) {
      final PsiIfStatement ifStatement = (PsiIfStatement)statement;
      checkIfStatement(ifStatement, definiteAssignment);
    }
    else if (statement instanceof PsiLabeledStatement) {
      final PsiLabeledStatement labeledStatement = (PsiLabeledStatement)statement;
      checkLabeledStatement(labeledStatement, definiteAssignment);
    }
    else if (statement instanceof PsiReturnStatement) {
      final PsiReturnStatement returnStatement = (PsiReturnStatement)statement;
      checkReturnStatement(returnStatement, definiteAssignment);
    }
    else if (statement instanceof PsiSwitchStatement) {
      final PsiSwitchStatement switchStatement = (PsiSwitchStatement)statement;
      checkSwitchStatement(switchStatement, definiteAssignment);
    }
    else if (statement instanceof PsiSynchronizedStatement) {
      final PsiSynchronizedStatement synchronizedStatement = (PsiSynchronizedStatement)statement;
      checkSynchronizedStatement(synchronizedStatement, definiteAssignment);
    }
    else if (statement instanceof PsiThrowStatement) {
      final PsiThrowStatement throwStatement = (PsiThrowStatement)statement;
      checkThrowStatement(throwStatement, definiteAssignment);
    }
    else if (statement instanceof PsiTryStatement) {
      final PsiTryStatement tryStatement = (PsiTryStatement)statement;
      checkTryStatement(tryStatement, definiteAssignment);
    }
    else if (statement instanceof PsiWhileStatement) {
      final PsiWhileStatement whileStatement = (PsiWhileStatement)statement;
      checkWhileStatement(whileStatement, definiteAssignment);
    }
  }

  private static void checkAssertStatement(PsiAssertStatement assertStatement, DefiniteAssignment definiteAssignment) {
    final boolean da = definiteAssignment.isDefinitelyAssigned();
    final boolean du = definiteAssignment.isDefinitelyUnassigned();
    final PsiExpression condition = assertStatement.getAssertCondition();
    checkExpression(condition, definiteAssignment, BooleanExpressionValue.WHEN_TRUE);
    final boolean resultDu = du && definiteAssignment.isDefinitelyUnassigned();
    definiteAssignment.set(da, du);
    checkExpression(condition, definiteAssignment, BooleanExpressionValue.WHEN_FALSE);
    checkExpression(assertStatement.getAssertDescription(), definiteAssignment, BooleanExpressionValue.UNDEFINED);
    definiteAssignment.set(da, resultDu);
  }

  private static void checkBreakStatement(PsiBreakStatement breakStatement, DefiniteAssignment definiteAssignment) {
    definiteAssignment.storeBeforeBreakStatement(breakStatement);
    definiteAssignment.set(true, true);
  }

  private static void checkContinueStatement(PsiContinueStatement continueStatement, DefiniteAssignment definiteAssignment) {
    definiteAssignment.storeBeforeContinueStatement(continueStatement);
    definiteAssignment.set(true, true);
  }

  private static void checkDeclarationStatement(PsiDeclarationStatement declarationStatement, DefiniteAssignment definiteAssignment) {
    for (PsiElement element : declarationStatement.getDeclaredElements()) {
      if (element instanceof PsiLocalVariable) {
        final PsiLocalVariable variable = (PsiLocalVariable)element;
        checkLocalVariable(variable, definiteAssignment);
      }
      else if (element instanceof PsiClass) {
        final PsiClass aClass = (PsiClass)element;
        final boolean da = definiteAssignment.isDefinitelyAssigned();
        final boolean du = definiteAssignment.isDefinitelyUnassigned();
        definiteAssignment.set(true, false);
        checkClass(aClass, definiteAssignment);
        definiteAssignment.set(da, du);
      }
      else {
        throw new AssertionError("unknown element declared: " + element);
      }
    }
  }

  private static void checkDoWhileStatement(PsiDoWhileStatement doWhileStatement, DefiniteAssignment definiteAssignment) {
    final boolean da = definiteAssignment.isDefinitelyAssigned();
    final boolean du = definiteAssignment.isDefinitelyUnassigned();
    final PsiExpression condition = doWhileStatement.getCondition();
    final PsiStatement body = doWhileStatement.getBody();
    checkStatement(body, definiteAssignment);
    checkExpression(condition, definiteAssignment, BooleanExpressionValue.WHEN_TRUE);
    definiteAssignment.set(da, definiteAssignment.isDefinitelyUnassigned() & du);
    checkStatement(body, definiteAssignment);
    definiteAssignment.andDefiniteAssignmentBeforeContinue(doWhileStatement);
    checkExpression(condition, definiteAssignment, BooleanExpressionValue.WHEN_FALSE);
    definiteAssignment.andDefiniteAssignmentBeforeBreak(doWhileStatement);
  }

  private static void checkExpressionListStatement(PsiExpressionListStatement expressionListStatement,
                                                   DefiniteAssignment definiteAssignment) {
    final PsiExpressionList expressionList = expressionListStatement.getExpressionList();
    for (PsiExpression expression : expressionList.getExpressions()) {
      checkExpression(expression, definiteAssignment, BooleanExpressionValue.UNDEFINED);
    }
  }

  private static void checkForeachStatement(PsiForeachStatement foreachStatement, DefiniteAssignment definiteAssignment) {
    checkExpression(foreachStatement.getIteratedValue(), definiteAssignment, BooleanExpressionValue.UNDEFINED);
    final boolean da = definiteAssignment.isDefinitelyAssigned();
    checkStatement(foreachStatement.getBody(), definiteAssignment);
    definiteAssignment.set(da, definiteAssignment.isDefinitelyUnassigned());
    definiteAssignment.andDefiniteAssignmentBeforeBreak(foreachStatement);
  }

  private static void checkForStatement(PsiForStatement forStatement, DefiniteAssignment definiteAssignment) {
    checkStatement(forStatement.getInitialization(), definiteAssignment);
    final boolean da = definiteAssignment.isDefinitelyAssigned();
    final boolean du = definiteAssignment.isDefinitelyUnassigned();
    final PsiExpression condition = forStatement.getCondition();
    checkExpression(condition, definiteAssignment, BooleanExpressionValue.WHEN_TRUE);
    checkStatement(forStatement.getBody(), definiteAssignment);
    definiteAssignment.andDefiniteAssignmentBeforeContinue(forStatement);
    checkStatement(forStatement.getUpdate(), definiteAssignment);
    // hack because javac does not match spec for incrementation part of for statement
    checkStatement(forStatement.getBody(), definiteAssignment);
    definiteAssignment.set(da, du);
    if (condition == null) {
      definiteAssignment.set(true, true);
    }
    else {
      checkExpression(condition, definiteAssignment, BooleanExpressionValue.WHEN_FALSE);
    }
    definiteAssignment.andDefiniteAssignmentBeforeBreak(forStatement);
  }

  private static void checkIfStatement(PsiIfStatement ifStatement, DefiniteAssignment definiteAssignment) {
    final boolean da = definiteAssignment.isDefinitelyAssigned();
    final boolean du = definiteAssignment.isDefinitelyUnassigned();
    final PsiExpression condition = ifStatement.getCondition();
    checkExpression(condition, definiteAssignment, BooleanExpressionValue.WHEN_TRUE);
    checkStatement(ifStatement.getThenBranch(), definiteAssignment);
    final boolean resultDa = definiteAssignment.isDefinitelyAssigned();
    final boolean resultDu = definiteAssignment.isDefinitelyUnassigned();
    definiteAssignment.set(da, du);
    checkExpression(condition, definiteAssignment, BooleanExpressionValue.WHEN_FALSE);
    checkStatement(ifStatement.getElseBranch(), definiteAssignment);
    definiteAssignment.and(resultDa, resultDu);
  }

  private static void checkLabeledStatement(PsiLabeledStatement labeledStatement, DefiniteAssignment definiteAssignment) {
    final PsiStatement statement = labeledStatement.getStatement();
    checkStatement(statement, definiteAssignment);
    definiteAssignment.andDefiniteAssignmentBeforeBreak(statement);
  }

  private static void checkReturnStatement(PsiReturnStatement returnStatement, DefiniteAssignment definiteAssignment) {
    definiteAssignment.storeBeforeReturn(returnStatement);
    checkExpression(returnStatement.getReturnValue(), definiteAssignment, BooleanExpressionValue.UNDEFINED);
    definiteAssignment.set(true, true);
  }

  private static void checkSwitchStatement(PsiSwitchStatement switchStatement, DefiniteAssignment definiteAssignment) {
    checkExpression(switchStatement.getExpression(), definiteAssignment, BooleanExpressionValue.UNDEFINED);
    final PsiCodeBlock body = switchStatement.getBody();
    if (body == null) {
      return;
    }
    final PsiStatement[] statements = body.getStatements();
    if (statements.length == 0) {
      return;
    }
    boolean defaultSeen = false;
    for (final PsiStatement statement : statements) {
      if (statement instanceof PsiSwitchLabelStatement) {
        final PsiSwitchLabelStatement switchLabelStatement = (PsiSwitchLabelStatement)statement;
        if (switchLabelStatement.isDefaultCase()) {
          defaultSeen = true;
        }
      }
      checkStatement(statement, definiteAssignment);
    }
    definiteAssignment.andDefiniteAssignmentBeforeBreak(switchStatement); // enum switch not specified
    definiteAssignment.and(defaultSeen, definiteAssignment.isDefinitelyUnassigned());
  }

  private static void checkSynchronizedStatement(PsiSynchronizedStatement synchronizedStatement, DefiniteAssignment definiteAssignment) {
    checkExpression(synchronizedStatement.getLockExpression(), definiteAssignment, BooleanExpressionValue.UNDEFINED);
    checkCodeBlock(synchronizedStatement.getBody(), definiteAssignment);
  }

  private static void checkThrowStatement(PsiThrowStatement throwStatement, DefiniteAssignment definiteAssignment) {
    checkExpression(throwStatement.getException(), definiteAssignment, BooleanExpressionValue.UNDEFINED);
    definiteAssignment.set(true, true);
  }

  private static void checkTryStatement(PsiTryStatement tryStatement, DefiniteAssignment definiteAssignment) {
    // try with resources not specified
    final boolean da = definiteAssignment.isDefinitelyAssigned();
    checkCodeBlock(tryStatement.getTryBlock(), definiteAssignment);
    final boolean du = definiteAssignment.isDefinitelyUnassigned();
    boolean resultDa = definiteAssignment.isDefinitelyAssigned();
    boolean resultDu = du;
    for (PsiCodeBlock catchBlock : tryStatement.getCatchBlocks()) {
      definiteAssignment.set(da, du);
      checkCodeBlock(catchBlock, definiteAssignment);
      resultDu &= definiteAssignment.isDefinitelyUnassigned();
      resultDa &= definiteAssignment.isDefinitelyAssigned();
    }
    final PsiCodeBlock finallyBlock = tryStatement.getFinallyBlock();
    if (finallyBlock != null) {
      definiteAssignment.set(da, definiteAssignment.isDefinitelyUnassigned());
      checkCodeBlock(finallyBlock, definiteAssignment);
      resultDu &= definiteAssignment.isDefinitelyUnassigned(); // spec problem
    }
    definiteAssignment.set(resultDa | definiteAssignment.isDefinitelyAssigned(), resultDu);
  }

  private static void checkWhileStatement(PsiWhileStatement whileStatement, DefiniteAssignment definiteAssignment) {
    final boolean da = definiteAssignment.isDefinitelyAssigned();
    final PsiExpression condition = whileStatement.getCondition();
    checkExpression(condition, definiteAssignment, BooleanExpressionValue.WHEN_TRUE);
    checkStatement(whileStatement.getBody(), definiteAssignment);
    definiteAssignment.andDefiniteAssignmentBeforeContinue(whileStatement);
    definiteAssignment.set(da, definiteAssignment.isDefinitelyUnassigned());
    checkExpression(condition, definiteAssignment, BooleanExpressionValue.WHEN_FALSE);
    definiteAssignment.andDefiniteAssignmentBeforeBreak(whileStatement);
  }

  private static void checkExpression(@Nullable PsiExpression expression,
                                      DefiniteAssignment definiteAssignment,
                                      BooleanExpressionValue value) {
    if (expression == null || definiteAssignment.stop()) {
      return;
    }
    if (PsiType.BOOLEAN.equals(expression.getType())) {
      final Object result = ExpressionUtils.computeConstantExpression(expression);
      if (Boolean.TRUE == result) {
        if (BooleanExpressionValue.WHEN_FALSE == value) {
          definiteAssignment.set(true, true);
        }
        return;
      }
      else if (Boolean.FALSE == result) {
        if (BooleanExpressionValue.WHEN_TRUE == value) {
          definiteAssignment.set(true, true);
        }
        return;
      }
    }
    if (expression instanceof PsiArrayAccessExpression) {
      final PsiArrayAccessExpression arrayAccessExpression = (PsiArrayAccessExpression)expression;
      checkArrayAccessExpression(arrayAccessExpression, definiteAssignment, value);
    }
    else if (expression instanceof PsiArrayInitializerExpression) {
      final PsiArrayInitializerExpression arrayInitializerExpression = (PsiArrayInitializerExpression)expression;
      checkArrayInitializerExpression(arrayInitializerExpression, definiteAssignment, value);
    }
    else if (expression instanceof PsiAssignmentExpression) {
      final PsiAssignmentExpression assignmentExpression = (PsiAssignmentExpression)expression;
      checkAssignmentExpression(assignmentExpression, definiteAssignment);
    }
    else if (expression instanceof PsiConditionalExpression) {
      final PsiConditionalExpression conditionalExpression = (PsiConditionalExpression)expression;
      checkConditionalExpression(conditionalExpression, definiteAssignment, value);
    }
    else if (expression instanceof PsiInstanceOfExpression) {
      final PsiInstanceOfExpression instanceOfExpression = (PsiInstanceOfExpression)expression;
      checkExpression(instanceOfExpression.getOperand(), definiteAssignment, value);
    }
    else if (expression instanceof PsiMethodCallExpression) {
      final PsiMethodCallExpression methodCallExpression = (PsiMethodCallExpression)expression;
      checkMethodCallExpression(methodCallExpression, definiteAssignment, value);
    }
    else if (expression instanceof PsiNewExpression) {
      final PsiNewExpression newExpression = (PsiNewExpression)expression;
      checkNewExpression(newExpression, definiteAssignment, value);
    }
    else if (expression instanceof PsiParenthesizedExpression) {
      final PsiParenthesizedExpression parenthesizedExpression = (PsiParenthesizedExpression)expression;
      checkExpression(parenthesizedExpression.getExpression(), definiteAssignment, value);
    }
    else if (expression instanceof PsiPolyadicExpression) {
      final PsiPolyadicExpression polyadicExpression = (PsiPolyadicExpression)expression;
      checkPolyadicExpression(polyadicExpression, definiteAssignment, value);
    }
    else if (expression instanceof PsiPostfixExpression) {
      final PsiPostfixExpression postfixExpression = (PsiPostfixExpression)expression;
      checkPostFixExpression(postfixExpression, definiteAssignment);
    }
    else if (expression instanceof PsiPrefixExpression) {
      final PsiPrefixExpression prefixExpression = (PsiPrefixExpression)expression;
      checkPrefixExpression(prefixExpression, definiteAssignment, value);
    }
    else if (expression instanceof PsiReferenceExpression) {
      final PsiReferenceExpression referenceExpression = (PsiReferenceExpression)expression;
      checkReferenceExpression(referenceExpression, definiteAssignment, value);
    }
    else if (expression instanceof PsiTypeCastExpression) {
      final PsiTypeCastExpression typeCastExpression = (PsiTypeCastExpression)expression;
      checkExpression(typeCastExpression.getOperand(), definiteAssignment, value);
    }
  }

  private static void checkArrayAccessExpression(PsiArrayAccessExpression arrayAccessExpression,
                                                 DefiniteAssignment definiteAssignment,
                                                 BooleanExpressionValue value) {
    checkExpression(arrayAccessExpression.getArrayExpression(), definiteAssignment, value);
    checkExpression(arrayAccessExpression.getIndexExpression(), definiteAssignment, value);
  }

  private static void checkArrayInitializerExpression(PsiArrayInitializerExpression arrayInitializerExpression,
                                                      DefiniteAssignment definiteAssignment,
                                                      BooleanExpressionValue value) {
    for (PsiExpression initializer : arrayInitializerExpression.getInitializers()) {
      checkExpression(initializer, definiteAssignment, value);
    }
  }

  private static void checkAssignmentExpression(PsiAssignmentExpression assignmentExpression, DefiniteAssignment definiteAssignment) {
    final PsiExpression lhs = assignmentExpression.getLExpression();
    final PsiReferenceExpression referenceExpression = getReferenceIfAssignmentOfVariable(lhs, definiteAssignment);
    if (referenceExpression == null) {
      checkExpression(lhs, definiteAssignment, BooleanExpressionValue.UNDEFINED);
      checkExpression(assignmentExpression.getRExpression(), definiteAssignment, BooleanExpressionValue.UNDEFINED);
    }
    else {
      final IElementType tokenType = assignmentExpression.getOperationTokenType();
      if (!JavaTokenType.EQ.equals(tokenType)) {
        definiteAssignment.valueAccess(referenceExpression);
      }
      checkExpression(assignmentExpression.getRExpression(), definiteAssignment, BooleanExpressionValue.UNDEFINED);
      definiteAssignment.assign(referenceExpression, true);
    }
  }

  private static PsiReferenceExpression getReferenceIfAssignmentOfVariable(PsiExpression lhs, DefiniteAssignment definiteAssignment) {
    lhs = ParenthesesUtils.stripParentheses(lhs);
    if (!(lhs instanceof PsiReferenceExpression)) {
      return null;
    }
    final PsiReferenceExpression referenceExpression = (PsiReferenceExpression)lhs;
    final PsiElement target = referenceExpression.resolve();
    if (!definiteAssignment.getVariable().equals(target)) {
      return null;
    }
    final PsiExpression qualifier = referenceExpression.getQualifierExpression();
    if (qualifier != null && (!(qualifier instanceof PsiThisExpression) || ((PsiThisExpression)qualifier).getQualifier() != null)) {
      return null;
    }
    return referenceExpression;
  }

  private static void checkConditionalExpression(PsiConditionalExpression conditionalExpression,
                                                 DefiniteAssignment definiteAssignment,
                                                 BooleanExpressionValue value) {
    final PsiExpression thenExpression = conditionalExpression.getThenExpression();
    final PsiExpression elseExpression = conditionalExpression.getElseExpression();
    if (thenExpression != null && PsiType.BOOLEAN.equals(thenExpression.getType()) &&
        elseExpression != null && PsiType.BOOLEAN.equals(elseExpression.getType())) {
      if (value == BooleanExpressionValue.WHEN_TRUE) {
        checkConditionalInternal(conditionalExpression, definiteAssignment, BooleanExpressionValue.WHEN_TRUE);
      }
      else if (value == BooleanExpressionValue.WHEN_FALSE) {
        checkConditionalInternal(conditionalExpression, definiteAssignment, BooleanExpressionValue.WHEN_FALSE);
      }
      else {
        final boolean da = definiteAssignment.isDefinitelyAssigned();
        final boolean du = definiteAssignment.isDefinitelyUnassigned();
        checkConditionalExpression(conditionalExpression, definiteAssignment, BooleanExpressionValue.WHEN_TRUE);
        final boolean resultDa = definiteAssignment.isDefinitelyAssigned();
        final boolean resultDu = definiteAssignment.isDefinitelyUnassigned();
        definiteAssignment.set(da, du);
        checkConditionalExpression(conditionalExpression, definiteAssignment, BooleanExpressionValue.WHEN_FALSE);
        definiteAssignment.and(resultDa, resultDu);
      }
    }
    else {
      checkConditionalInternal(conditionalExpression, definiteAssignment, BooleanExpressionValue.UNDEFINED);
    }
  }

  private static void checkConditionalInternal(PsiConditionalExpression conditionalExpression,
                                               DefiniteAssignment definiteAssignment,
                                               BooleanExpressionValue value) {
    final boolean da = definiteAssignment.isDefinitelyAssigned();
    final boolean du = definiteAssignment.isDefinitelyUnassigned();
    final PsiExpression condition = conditionalExpression.getCondition();
    checkExpression(condition, definiteAssignment, BooleanExpressionValue.WHEN_TRUE);
    checkExpression(conditionalExpression.getThenExpression(), definiteAssignment, value);
    final boolean resultDa = definiteAssignment.isDefinitelyAssigned();
    final boolean resultDu = definiteAssignment.isDefinitelyUnassigned();
    definiteAssignment.set(da, du);
    checkExpression(condition, definiteAssignment, BooleanExpressionValue.WHEN_FALSE);
    checkExpression(conditionalExpression.getElseExpression(), definiteAssignment, value);
    definiteAssignment.and(resultDa, resultDu);
  }

  private static void checkMethodCallExpression(PsiMethodCallExpression methodCallExpression,
                                                DefiniteAssignment definiteAssignment,
                                                BooleanExpressionValue value) {
    final PsiReferenceExpression methodExpression = methodCallExpression.getMethodExpression();
    final PsiExpression qualifier = methodExpression.getQualifierExpression();
    checkExpression(qualifier, definiteAssignment, value);
    final PsiExpressionList argumentList = methodCallExpression.getArgumentList();
    for (PsiExpression argument : argumentList.getExpressions()) {
      checkExpression(argument, definiteAssignment, value);
    }
  }

  private static void checkNewExpression(PsiNewExpression newExpression,
                                         DefiniteAssignment definiteAssignment,
                                         BooleanExpressionValue value) {
    final PsiExpressionList argumentList = newExpression.getArgumentList();
    if (argumentList != null) {
      for (PsiExpression argument : argumentList.getExpressions()) {
        checkExpression(argument, definiteAssignment, value);
      }
    }
    final PsiAnonymousClass anonymousClass = newExpression.getAnonymousClass();
    if (anonymousClass != null) {
      final boolean du = definiteAssignment.isDefinitelyUnassigned();
      definiteAssignment.set(definiteAssignment.isDefinitelyAssigned(), false);
      checkAnonymousClass(anonymousClass, definiteAssignment);
      definiteAssignment.set(definiteAssignment.isDefinitelyAssigned(), du);
    }
    for (PsiExpression dimension : newExpression.getArrayDimensions()) {
      checkExpression(dimension, definiteAssignment, value);
    }
    final PsiArrayInitializerExpression arrayInitializer = newExpression.getArrayInitializer();
    if (arrayInitializer != null) {
      checkExpression(arrayInitializer, definiteAssignment, value);
    }
  }

  private static void checkPolyadicExpression(PsiPolyadicExpression polyadicExpression,
                                              DefiniteAssignment definiteAssignment,
                                              BooleanExpressionValue value) {
    final PsiExpression[] operands = polyadicExpression.getOperands();
    final IElementType tokenType = polyadicExpression.getOperationTokenType();
    if (JavaTokenType.OROR == tokenType || JavaTokenType.ANDAND == tokenType) {
      for (int i = 1; i < operands.length; i++) {
        checkBinaryExpression(operands[i - 1], operands[i], tokenType == JavaTokenType.ANDAND, definiteAssignment, value);
      }
    }
    else {
      for (PsiExpression operand : operands) {
        checkExpression(operand, definiteAssignment, BooleanExpressionValue.UNDEFINED);
      }
    }
  }

  private static void checkBinaryExpression(PsiExpression lhs,
                                            PsiExpression rhs,
                                            boolean and,
                                            DefiniteAssignment definiteAssignment,
                                            BooleanExpressionValue value) {
    if (and ? value == BooleanExpressionValue.WHEN_FALSE : value == BooleanExpressionValue.WHEN_TRUE) {
      final boolean da = definiteAssignment.isDefinitelyAssigned();
      final boolean du = definiteAssignment.isDefinitelyUnassigned();
      checkExpression(lhs, definiteAssignment, and ? BooleanExpressionValue.WHEN_FALSE : BooleanExpressionValue.WHEN_TRUE);
      final boolean resultDa = definiteAssignment.isDefinitelyAssigned();
      final boolean resultDu = definiteAssignment.isDefinitelyUnassigned();
      definiteAssignment.set(da, du);
      checkExpression(lhs, definiteAssignment, and ? BooleanExpressionValue.WHEN_TRUE : BooleanExpressionValue.WHEN_FALSE);
      checkExpression(rhs, definiteAssignment, and ? BooleanExpressionValue.WHEN_FALSE : BooleanExpressionValue.WHEN_TRUE);
      definiteAssignment.and(resultDa, resultDu);
    }
    else if (and ? value == BooleanExpressionValue.WHEN_TRUE : value == BooleanExpressionValue.WHEN_FALSE) {
      checkExpression(lhs, definiteAssignment, and ? BooleanExpressionValue.WHEN_TRUE : BooleanExpressionValue.WHEN_FALSE);
      checkExpression(rhs, definiteAssignment, and ? BooleanExpressionValue.WHEN_TRUE : BooleanExpressionValue.WHEN_FALSE);
    }
    else {
      final boolean da = definiteAssignment.isDefinitelyAssigned();
      final boolean du = definiteAssignment.isDefinitelyUnassigned();
      checkBinaryExpression(lhs, rhs, false, definiteAssignment, BooleanExpressionValue.WHEN_TRUE);
      final boolean resultDa = definiteAssignment.isDefinitelyAssigned();
      final boolean resultDu = definiteAssignment.isDefinitelyUnassigned();
      definiteAssignment.set(da, du);
      checkBinaryExpression(lhs, rhs, false, definiteAssignment, BooleanExpressionValue.WHEN_FALSE);
      definiteAssignment.and(resultDa, resultDu);
    }
  }

  private static void checkPostFixExpression(PsiPostfixExpression postfixExpression, DefiniteAssignment definiteAssignment) {
    checkExpression(postfixExpression.getOperand(), definiteAssignment, BooleanExpressionValue.UNDEFINED);
  }

  private static void checkPrefixExpression(PsiPrefixExpression prefixExpression,
                                            DefiniteAssignment definiteAssignment,
                                            BooleanExpressionValue value) {
    final IElementType tokenType = prefixExpression.getOperationTokenType();
    if (JavaTokenType.EXCL == tokenType) {
      if (value == BooleanExpressionValue.WHEN_TRUE) {
        checkExpression(prefixExpression.getOperand(), definiteAssignment, BooleanExpressionValue.WHEN_FALSE);
      }
      else if (value == BooleanExpressionValue.WHEN_FALSE) {
        checkExpression(prefixExpression.getOperand(), definiteAssignment, BooleanExpressionValue.WHEN_TRUE);
      }
      else {
        final boolean da = definiteAssignment.isDefinitelyAssigned();
        final boolean du = definiteAssignment.isDefinitelyUnassigned();
        checkPrefixExpression(prefixExpression, definiteAssignment, BooleanExpressionValue.WHEN_TRUE);
        final boolean resultDa = definiteAssignment.isDefinitelyAssigned();
        final boolean resultDu = definiteAssignment.isDefinitelyUnassigned();
        definiteAssignment.set(da, du);
        checkPrefixExpression(prefixExpression, definiteAssignment, BooleanExpressionValue.WHEN_FALSE);
        definiteAssignment.and(resultDa, resultDu);
      }
    }
    else {
      checkExpression(prefixExpression.getOperand(), definiteAssignment, BooleanExpressionValue.UNDEFINED);
    }
  }

  private static void checkReferenceExpression(PsiReferenceExpression referenceExpression,
                                               DefiniteAssignment definiteAssignment,
                                               BooleanExpressionValue value) {
    final PsiExpression qualifier = referenceExpression.getQualifierExpression();
    if (qualifier != null) {
      checkExpression(qualifier, definiteAssignment, value);
    }
    if (!definiteAssignment.getVariable().equals(referenceExpression.resolve())) {
      return;
    }
    if (PsiUtil.isAccessedForWriting(referenceExpression)) {
      definiteAssignment.assign(referenceExpression, false);
    }
    else {
      if (qualifier != null) {
        if (!(qualifier instanceof PsiThisExpression)) {
          return;
        }
        final PsiThisExpression thisExpression = (PsiThisExpression)qualifier;
        if (thisExpression.getQualifier() != null) {
          return;
        }
      }
      definiteAssignment.valueAccess(referenceExpression);
    }
  }

  private enum BooleanExpressionValue {
    WHEN_TRUE, WHEN_FALSE, UNDEFINED
  }
}