private static void simpletest() throws Exception {
    // load the class without initialization
    new Statement(Class.class,"forName",new Object[]{
            "ClassForName$Bean",false,Bean.class.getClassLoader()
    }).execute();
    if (initialized) {
        throw new RuntimeException("Should not be initialized");
    }

    // load the class and initialize it
    new Statement(Class.class,true,Bean.class.getClassLoader()
    }).execute();
    if (!initialized) {
        throw new RuntimeException("Should be initialized");
    }
}

@SuppressWarnings("unchecked")
public static <E> void setMethodValue(E obj,Method method,Object... args) {
    try {
        method.setAccessible(true);

        method.invoke(obj,args);

    } catch (InvocationTargetException | illegalaccessexception | IllegalArgumentException e) {
        // e.printstacktrace();
        try {
            if (obj != null) {
                Statement stmt = new Statement(obj,method.getName(),args);
                stmt.execute();
            }

        } catch (Exception e1) {
            // e1.printstacktrace();
        }
    }
}

public static void setQueryTimeout(java.sql.Statement stmt,int timeout) throws sqlException {
  if (timeout < 0) {
    LOG.info("Invalid query timeout " + timeout);
    return;
  }
  try {
    stmt.setQueryTimeout(timeout);
  } catch (sqlException e) {
    String message = e.getMessage() == null ? null : e.getMessage().toLowerCase();
    if (e instanceof sqlFeatureNotSupportedException ||
       (message != null && (message.contains("implemented") || message.contains("supported")))) {
      LOG.info("setQueryTimeout is not supported");
      return;
    }
    throw e;
  }
}

@Override
        protected void initialize(Class type,Object oldInstance,Object newInstance,Encoder out) {
//            p("image painter delegate called");
            super.initialize(type,oldInstance,newInstance,out);
            //p("old instance = " + oldInstance);
            //p("owner = " + ((XMLEncoder)out).getowner());
            PersistenceOwner owner = (PersistenceOwner)((XMLEncoder)out).getowner();
            ImagePainter ip = (ImagePainter)oldInstance;
//            p("need to convert string: " + ip.getimageString());
//            String s = owner.toXMLURL(ip.getimageString());
//            p("converted to: " + s);
                //out.writeExpression(new Expression(oldInstance,owner,"fromXMLURL",new Object[]{ip.getimageString()}));
                //out.writeStatement(new Statement(owner,new Object[]{ip.getimageString()}));
                //out.writeStatement(new Statement(oldInstance,"setimageString",new Object[]{
                //new Expression(oldInstance,new Object[]{ip.getimageString()})
                //}));

            out.writeStatement(new Statement(oldInstance,"setResolver",new Object[]{owner}));
//            out.writeStatement(new Statement(oldInstance,new Object[]{s}));
        }

public void testinitialize_normalBeanInfo() throws Exception {
    CollectingEncoder enc = new CollectingEncoder();
    MockPersistenceDelegate pd = new MockPersistenceDelegate();
    MockFoo2 b = new MockFoo2(2);
    MockFoo2 b2 = new MockFoo2(3);
    Iterator<Statement> iter;

    pd.writeObject(b,enc);
    pd.writeObject(b2,enc);
    enc.clearCache();
    pd.initialize(MockFoo2.class,b,b2,enc);

    // XXX RI stores much more statements to the stream
    iter = enc.statements();
    // assertNotNull("required statement not found",// findStatement(iter,"myget",null));
    assertNotNull("required statement not found",findStatement(iter,null,"myset",new Object[] { new Integer(2) }));
}

public void setValueAt(Object obj,int row,int col) {
    Field field = data.get(row);
    if (field != null) {
        try {
            switch (col) {
                case 1:
                    if (field.getType().getSimpleName().equalsIgnoreCase("int")) {
                        new Statement(appContext,methods.get("set" + field.getName().toLowerCase()).getName(),new Object[]{Integer.parseInt((String) obj)}).execute();
                    } else if (field.getType().getSimpleName().equalsIgnoreCase("boolean")) {
                        field.set(appContext,Boolean.parseBoolean((String) obj));
                    } else if (field.getType().getSimpleName().equalsIgnoreCase("string")) {
                        field.set(appContext,obj);
                    }
            }
        } catch (Exception e) {
            e.printstacktrace();
        }
    }
    super.fireTableDataChanged();
}

public void testinitialize_normalBeanInfo() throws Exception {
    CollectingEncoder enc = new CollectingEncoder();
    MockPersistenceDelegate pd = new MockPersistenceDelegate();
    MockFoo2 b = new MockFoo2(2);
    MockFoo2 b2 = new MockFoo2(3);
    Iterator<Statement> iter;

    pd.writeObject(b,new Object[] { new Integer(2) }));
}

@Override
protected void initialize(Class<?> type,Encoder out) {
    super.initialize(type,out);

    Public<String,String> map = (Public) oldInstance;
    for (Entry<String,String> entry : map.getAll()) {
        String[] args = {entry.getKey(),entry.getValue()};
        out.writeStatement(new Statement(oldInstance,"put",args));
    }
}

private static void testStatement() {
    Object[] array = { new Object() };
    Statement statement = new Statement(null,array);
    test(statement.getArguments());
    array[0] = null;
    test(statement.getArguments());
    statement.getArguments()[0] = null;
    test(statement.getArguments());
}

@Override
protected void initialize(Class<?> type,args));
    }
}

private static void testStatement() {
    Object[] array = { new Object() };
    Statement statement = new Statement(null,array);
    test(statement.getArguments());
    array[0] = null;
    test(statement.getArguments());
    statement.getArguments()[0] = null;
    test(statement.getArguments());
}

@Override
protected void initialize(Class<?> type,args));
    }
}

private static void testStatement() {
    Object[] array = { new Object() };
    Statement statement = new Statement(null,array);
    test(statement.getArguments());
    array[0] = null;
    test(statement.getArguments());
    statement.getArguments()[0] = null;
    test(statement.getArguments());
}

@Override
protected void initialize(Class<?> type,Encoder out) {
  java.util.Collection oldO = (java.util.Collection) oldInstance;
  java.util.Collection newO = (java.util.Collection) newInstance;

  if (newO.size() != 0) {
    out.writeStatement(new Statement(oldInstance,"clear",new Object[] {}));
  }
  for (Iterator i = oldO.iterator(); i.hasNext();) {
    out.writeStatement(new Statement(oldInstance,"add",new Object[] {i.next()}));
  }
}

@Override
protected void initialize(Class<?> type,Encoder out) {
  Timestamp ts = (Timestamp)oldInstance;
  Object[] args = { ts.getNanos() };
  Statement stmt = new Statement(oldInstance,"setNanos",args);
  out.writeStatement(stmt);
}

@Override
protected void initialize(Class type,Encoder out) {
  Iterator ite = ((Collection) oldInstance).iterator();
  while (ite.hasNext()) {
    out.writeStatement(new Statement(oldInstance,new Object[] {ite.next()}));
  }
}

@Override
protected void initialize(Class<?> type,args));
    }
}

private static void testStatement() {
    Object[] array = { new Object() };
    Statement statement = new Statement(null,array);
    test(statement.getArguments());
    array[0] = null;
    test(statement.getArguments());
    statement.getArguments()[0] = null;
    test(statement.getArguments());
}

@Override
protected void initialize(Class<?> type,args));
    }
}

private static void testStatement() {
    Object[] array = { new Object() };
    Statement statement = new Statement(null,array);
    test(statement.getArguments());
    array[0] = null;
    test(statement.getArguments());
    statement.getArguments()[0] = null;
    test(statement.getArguments());
}

protected void initialize(Class type,Encoder out)
{
  Iterator ite = ((Collection) oldInstance).iterator();

  while (ite.hasNext())
    {
      out.writeStatement(new Statement(oldInstance,new Object[] { ite.next() }));

    }

}

/** Scans the argument and calls one of event methods. See
 * the introduction of this class for details.
 *
 * @param stmt The statement to serialize.
 */
public void writeStatement(Statement stmt)
{
  // This is a simplified version of writeExpression. Everything
  // that would not create something that is embedded in a <void> tag
  // is left out (instantiation,getters,...).
  // Todo: Is this the right thing to do?

  String methodName = stmt.getmethodName();
  Object target = stmt.getTarget();
  Object[] args = stmt.getArguments();

  if (target == Array.class && methodName.equals("set"))
    {
      arraySet(args[1].toString());
      return;
    }

  if (target instanceof List)
    {
      if (methodName.equals("set"))
        {
          listSet();
          return;
        }
    }

  // If nothing else Could be used then this is a normal
  // method invocation.
  methodInvocation(methodName);
}

protected void initialize(Class type,Encoder out)
{
  Map map = (Map) oldInstance;
  Iterator ite = map.keySet().iterator();

  while (ite.hasNext())
    {
      Object key = ite.next();
      out.writeStatement(new Statement(oldInstance,new Object[] { key,map.get(key) }));

    }

}

protected void initialize(Class type,new Object[] { ite.next() }));

    }

}

/** Scans the argument and calls one of event methods. See
 * the introduction of this class for details.
 * 
 * @param stmt The statement to serialize.
 */
public void writeStatement(Statement stmt)
{
  // This is a simplified version of writeExpression. Everything
  // that would not create something that is embedded in a <void> tag
  // is left out (instantiation,...).
  // Todo: Is this the right thing to do?

  String methodName = stmt.getmethodName();
  Object target = stmt.getTarget();
  Object[] args = stmt.getArguments();

  if (target == Array.class && methodName.equals("set"))
    {
      arraySet(args[1].toString());
      return;
    }

  if (target instanceof List)
    {
      if (methodName.equals("set"))
        {
          listSet();
          return;
        }
    }

  // If nothing else Could be used then this is a normal
  // method invocation.
  methodInvocation(methodName);
}

protected void initialize(Class type,map.get(key) }));

    }

}

public BooleanInvocationHandler(Object target,String methodName) {
    // Create the true and false statements.
    falseStatement = new Statement(target,methodName,new Object[] { Boolean.FALSE });

    trueStatement = new Statement(target,new Object[] { Boolean.TRUE });
}

@Override
public void itemStateChanged(ItemEvent evt) {
    Statement statement = (evt.getStateChange() == ItemEvent.deselectED) ? falseStatement
            : trueStatement;

    try {
        statement.execute();
    } catch (Exception ex) {
        LOG.log(Level.FINE,"Couldn't execute boolean method via Statement "
                        + statement,ex);
    }
}

@Override
protected Expression instantiate(Object oldInstance,Encoder out) {
    Area a = (Area)oldInstance;

    //use the default constructor
    AffineTransform tx = new AffineTransform();
    PathIterator itr = a.getPathIterator(tx);

    GeneralPath path = new GeneralPath();
    out.writeExpression(new Expression(path,GeneralPath.class,"new",new Object[0]));

    while (!itr.isDone()) {
        float[] segment = new float[6]; //must use floats because lineto etc use floats
        int pathType = itr.currentSegment(segment);

        switch (pathType) {
            case PathIterator.SEG_CLOSE:
                out.writeStatement(new Statement(path,"closePath",new Object[0]));
                break;
            case PathIterator.SEG_CUBICTO:
                out.writeStatement(new Statement(path,"curveto",new Object[] {segment[0],segment[1],segment[2],segment[3],segment[4],segment[5]}));
                break;
            case PathIterator.SEG_LINeto:
                out.writeStatement(new Statement(path,"lineto",segment[1]}));
                break;
            case PathIterator.SEG_MOVeto:
                out.writeStatement(new Statement(path,"moveto",segment[1]}));
                break;
            case PathIterator.SEG_QUADTO:
                out.writeStatement(new Statement(path,"quadTo",segment[3]}));
                break;
        }
        itr.next();
    }

    return new Expression(a,Area.class,new Object[] {path});
}

@Override
protected void initialize(Class<?> type,Encoder out) {
    GeneralPath a = (GeneralPath)oldInstance;

    AffineTransform tx = new AffineTransform();
    PathIterator itr = a.getPathIterator(tx);

    out.writeStatement(new Statement(a,"setwindingRule",new Object[] {a.getwindingRule()}));

    while (!itr.isDone()) {
        float[] segment = new float[6]; //must use floats because lineto etc use floats
        int pathType = itr.currentSegment(segment);

        switch (pathType) {
            case PathIterator.SEG_CLOSE:
                out.writeStatement(new Statement(a,new Object[0]));
                break;
            case PathIterator.SEG_CUBICTO:
                out.writeStatement(new Statement(a,segment[5]}));
                break;
            case PathIterator.SEG_LINeto:
                out.writeStatement(new Statement(a,segment[1]}));
                break;
            case PathIterator.SEG_MOVeto:
                out.writeStatement(new Statement(a,segment[1]}));
                break;
            case PathIterator.SEG_QUADTO:
                out.writeStatement(new Statement(a,segment[3]}));
                break;
        }
        itr.next();
    }
}

@Override
protected void initialize(Class<?> type,Encoder out) {
    //u.p("rh init ");
    RenderingHints rh = (RenderingHints)oldInstance;
    out.writeStatement(new Statement(oldInstance,new Object[] {RenderingHints.KEY_ANTIALIASING,RenderingHints.VALUE_ANTIALIAS_ON}));
    //u.p("done");
}

@Override
protected void initialize(Class<?> type,args));
    }
}

private static void testStatement() {
    Object[] array = { new Object() };
    Statement statement = new Statement(null,array);
    test(statement.getArguments());
    array[0] = null;
    test(statement.getArguments());
    statement.getArguments()[0] = null;
    test(statement.getArguments());
}

@Override
protected void initialize(Class<?> type,args));
    }
}

private static void testStatement() {
    Object[] array = { new Object() };
    Statement statement = new Statement(null,array);
    test(statement.getArguments());
    array[0] = null;
    test(statement.getArguments());
    statement.getArguments()[0] = null;
    test(statement.getArguments());
}

public BooleanInvocationHandler(Object target,new Object[] { Boolean.TRUE });
}

public void itemStateChanged(ItemEvent evt) {
    Statement statement = (evt.getStateChange() == ItemEvent.deselectED) ? falseStatement
            : trueStatement;

    try {
        statement.execute();
    } catch (Exception ex) {
        LOG.log(Level.FINE,ex);
    }
}

@Override
protected void initialize(Class<?> type,args));
    }
}

protected static void replaceExpression(JSExpression expression,String newExpression)
        throws IncorrectOperationException {

    final ASTNode fromText = JSChangeUtil.createStatementFromText(expression.getProject(),newExpression + ';');
    final PsiElement element = fromText != null ? fromText.getPsi() : null;

    final JSExpressionStatement expressionStatement = element instanceof JSExpressionStatement ? (JSExpressionStatement) element:null;
    if (expressionStatement == null) {
        return;
    }
    final JSExpression newExp = expressionStatement.getExpression();
    final ASTNode newExpressionNode = newExp.getNode();
    final ASTNode expressionNode = expression.getNode();
    final PsiElement parent = expression.getParent();
    final ASTNode parentNode = parent.getNode();
    parentNode.replaceChild(expressionNode,newExpressionNode);
   // final CodeStyleManager styleManager = manager.getCodeStyleManager();
   // styleManager.reformat(newExpressionNode.getPsi());
}

public static void replaceSimplifiableImplicitAssignment(JSIfStatement statement,boolean negated)
        throws IncorrectOperationException {
    final JSElement              prevstatement        = (JSElement) JSElementFactory.getNonWhiteSpaceSibling(statement,false);
    final JSExpression           condition            = statement.getCondition();
    final String                 conditionText        = (negated ? BoolUtils.getNegatedExpressionText(condition) : condition.getText());
    final JSExpressionStatement  assignmentStatement  = (JSExpressionStatement) ConditionalUtils.stripBraces(statement.getThen());
    final JSAssignmentExpression assignmentExpression = (JSAssignmentExpression) assignmentStatement.getExpression();
    final IElementType           operator             = assignmentExpression.getoperationSign();
    final String                 operand              = BinaryOperatorUtils.getoperatorText(operator);
    final JSExpression           lhs                  = assignmentExpression.getLOperand();
    final String                 lhsText              = lhs.getText();

    JSElementFactory.replaceStatement(statement,lhsText + operand + conditionText + ';');

    assert (prevstatement != null);

    JSElementFactory.removeElement(prevstatement);
}

@Override
public boolean satisfiedBy(@NotNull PsiElement element) {
          if (!ExpressionUtil.isIncrementDecrementExpression(element)) {
              return false;
          }
          if (ErrorUtil.containsError(element)) {
              return false;
          }

          final PsiElement parent = element.getParent();

          if (parent instanceof JSExpressionStatement) {
              return false;
          }

          final Jsstatement containingStatement = TreeUtil.getParentOfType(element,Jsstatement.class);

          if (element instanceof JSPostfixExpression &&
              (containingStatement instanceof JSReturnStatement ||
               containingStatement instanceof JSThrowStatement)) {
              return false;
          }
          return (containingStatement != null);
      }

public static boolean containsTestsInFiles(JSFile file)
{
    JSSourceElement[] statements = file.getStatements();
    for(JSSourceElement statement : statements)
    {
        if(statement instanceof JSExpressionStatement)
        {
            JSExpression expression = ((JSExpressionStatement) statement).getExpression();
            if(expression instanceof JSCallExpression)
            {
                JSExpression methodExpression = ((JSCallExpression) expression).getmethodExpression();
                if(methodExpression instanceof JSReferenceExpression)
                {
                    JSExpression qualifier = ((JSReferenceExpression) methodExpression).getQualifier();
                    if(qualifier != null)
                    {
                        continue;
                    }
                    String referencedname = ((JSReferenceExpression) methodExpression).getReferencedname();
                    if("describe".equals(referencedname))
                    {
                        JSArgumentList argumentList = ((JSCallExpression) expression).getArgumentList();
                        if(argumentList != null && argumentList.getArguments().length == 2)
                        {
                            return true;
                        }
                    }
                }
            }
        }
    }
    return false;
}

@Test
public void testPropertyIsGenerated()
{
    List<JSExpressionStatement> methods = new ArrayList<JSExpressionStatement>();
    methods.add(new MockJSExpressionStatement(new MockJSAssignmentExpression("util.","property","'value'")));

    String result = converter.buildUtilPatternString(null,new JSExpression[0],methods,"util");
    assertTrue(result.contains("property: 'value'"));
}

@Test
public void indexPropertyIsConverted()
{
    List<JSExpressionStatement> methods = new ArrayList<JSExpressionStatement>();
    methods.add(new MockJSExpressionStatement(new MockJSAssignmentExpression(new MockJSDeFinitionExpressionWithIndexedProperty("util","'-test-'"),"value")));

    String result = converter.buildUtilPatternString(null,"util");
    assertTrue(result.contains("-test-': value"));
}

public JavaScriptKeywordCompletionContributor()
{
    extend(CompletionType.BASIC,StandardPatterns.psiElement().withParent(JSReferenceExpression.class),new CompletionProvider()
    {
        @requiredReadAction
        @Override
        public void addCompletions(@NotNull CompletionParameters parameters,ProcessingContext context,@NotNull CompletionResultSet result)
        {
            PsiElement position = parameters.getPosition();
            JSReferenceExpression parent = (JSReferenceExpression) position.getParent();
            if(parent.getQualifier() != null)
            {
                return;
            }

            boolean parentIsstatement = parent.getParent() instanceof JSExpressionStatement;

            LookupElementBuilder functionKeyword = LookupElementBuilder.create("function");
            functionKeyword = functionKeyword.bold();
            if(parentIsstatement)
            {
                functionKeyword = functionKeyword.withInsertHandler(SpaceInsertHandler.INSTANCE);
            }
            else
            {
                functionKeyword = functionKeyword.withInsertHandler(ParenthesesInsertHandler.getInstance(false));
                functionKeyword = functionKeyword.withPresentableText("function()");
            }

            result.addElement(functionKeyword);

            result.addElement(LookupElementBuilder.create("var").withInsertHandler(SpaceInsertHandler.INSTANCE).bold());
        }
    });
}

@Override
public int getTextEndOffset(@NotNull PsiElement element)
{
    if(element instanceof JSDeFinitionExpression)
    {
        element = PsiTreeUtil.getParentOfType(element,JSExpressionStatement.class);
    }
    return element.getTextRange().getEndOffset();
}

protected CreateClassDialog(final Project project,String className,String packageName,boolean isInterface)
{
    super(project,false);

    setTitle(JavaScriptBundle.message(isInterface ? "create.interface.dialog.title" : "create.class.dialog.title"));
    setModal(true);

    myPackageName.getDocument().addDocumentListener(new DocumentAdapter()
    {
        @Override
        protected void textChanged(final DocumentEvent e)
        {
            String text = getPackageName();
            boolean enabled;
            if(text.length() == 0)
            {
                enabled = true;
            }
            else
            {
                ASTNode node = JSChangeUtil.createJSTreeFromText(project,text);
                PsiElement elt;
                enabled = node != null &&
                        (elt = node.getPsi()) instanceof JSExpressionStatement &&
                        (elt = ((JSExpressionStatement) elt).getExpression()) instanceof JSReferenceExpression &&
                        ((JSReferenceExpression) elt).getReferencedname() != null &&
                        elt.textMatches(text);
            }
            getoKAction().setEnabled(enabled);
        }
    });

    myClassName.setText(className);
    myPackageName.setText(packageName);

    init();
}

@Override public void visitJSExpressionStatement(
        @NotNull JSExpressionStatement statement) {
    super.visitJSExpressionStatement(statement);
    if (!(statement.getExpression()instanceof JSNewExpression)) {
        return;
    }
    final JSNewExpression newExpression =
            (JSNewExpression) statement.getExpression();
    final JSExpression methodExpression =
            newExpression.getmethodExpression();
    if (methodExpression == null) {
        return;
    }
    registerError(methodExpression);
}

@Override public void visitJSExpressionStatement(JSExpressionStatement jsExpressionStatement) {
    super.visitJSExpressionStatement(jsExpressionStatement);
    final JSExpression expression = jsExpressionStatement.getExpression();

    if (!(expression instanceof JSReferenceExpression)) {
        return;
    }
    @NonNls final String text = expression.getText();
    if (!"debugger".equals(text)) {
        return;
    }
    registerError(expression);
}

public static boolean isAssignment(Jsstatement statement,String value) {
    if (statement == null || !(statement instanceof JSExpressionStatement)) {
        return false;
    }

    final JSExpression expression = ((JSExpressionStatement) statement).getExpression();

    if (!(expression instanceof JSAssignmentExpression)) {
        return false;
    }

    final JSExpression rhs = ((JSAssignmentExpression) expression).getROperand();

    return (rhs != null && rhs.getText().equals(value));
}

public static boolean isAssignment(Jsstatement statement) {
    if (!(statement instanceof JSExpressionStatement)) {
        return false;
    }

    final JSExpressionStatement expressionStatement = (JSExpressionStatement) statement;

    return (expressionStatement.getExpression() instanceof JSAssignmentExpression);
}

public static boolean isSimplifiableAssignment(JSIfStatement ifStatement,boolean negated) {
    final Jsstatement thenBranch = ConditionalUtils.stripBraces(ifStatement.getThen());
    final Jsstatement elseBranch = ConditionalUtils.stripBraces(ifStatement.getElse());

    final boolean isAssignment;

    if (negated) {
        isAssignment = (ConditionalUtils.isAssignment(thenBranch,BoolUtils.FALSE) &&
                        ConditionalUtils.isAssignment(elseBranch,BoolUtils.TRUE));
    } else {
        isAssignment = (ConditionalUtils.isAssignment(thenBranch,BoolUtils.TRUE) &&
                        ConditionalUtils.isAssignment(elseBranch,BoolUtils.FALSE));
    }

    if (isAssignment) {
        final JSAssignmentExpression thenExpression = (JSAssignmentExpression) ((JSExpressionStatement) thenBranch).getExpression();
        final JSAssignmentExpression elseExpression = (JSAssignmentExpression) ((JSExpressionStatement) elseBranch).getExpression();
        final IElementType           thenSign       = thenExpression.getoperationSign();
        final IElementType           elseSign       = elseExpression.getoperationSign();

        if (!thenSign.equals(elseSign)) {
            return false;
        }

        final JSExpression thenLhs = thenExpression.getLOperand();
        final JSExpression elseLhs = elseExpression.getLOperand();

        return EquivalenceChecker.expressionsAreEquivalent(thenLhs,elseLhs);
    } else {
        return false;
    }
}

public static void replaceSimplifiableAssignment(JSIfStatement statement,boolean negated)
        throws IncorrectOperationException {
    final JSExpression           condition            = statement.getCondition();
    final String                 conditionText        = (negated ? BoolUtils.getNegatedExpressionText(condition) : condition.getText());
    final JSExpressionStatement  assignmentStatement  = (JSExpressionStatement) ConditionalUtils.stripBraces(statement.getThen());
    final JSAssignmentExpression assignmentExpression = (JSAssignmentExpression) assignmentStatement.getExpression();
    final IElementType           operator             = assignmentExpression.getoperationSign();
    final String                 operand              = BinaryOperatorUtils.getoperatorText(operator);
    final JSExpression           lhs                  = assignmentExpression.getLOperand();
    final String                 lhsText              = lhs.getText();

    JSElementFactory.replaceStatement(statement,lhsText + operand + conditionText + ';');
}

private static void getAssignmentReplacement(StringBuilder buffer,JSIfStatement ifStatement) {
    final JSExpression           condition  = ifStatement.getCondition();
    final JSExpressionStatement  thenBranch = (JSExpressionStatement) ConditionalUtils.stripBraces(ifStatement.getThen());
    final JSAssignmentExpression thenAssign = (JSAssignmentExpression) thenBranch.getExpression();
    final JSExpression           thenRhs    = thenAssign.getROperand();
    final String                 operator   = BinaryOperatorUtils.getoperatorText(thenAssign.getoperationSign());
    final Jsstatement            elseBranch = ifStatement.getElse();

    assert (thenRhs != null);

    buffer.append(thenAssign.getLOperand().getText())
          .append(operator)
          .append(ParenthesesUtils.getParenthesized(condition,ParenthesesUtils.CONDITIONAL_PRECENDENCE))
          .append(TERNARY_QUESTION)
          .append(ParenthesesUtils.getParenthesized(thenRhs,ParenthesesUtils.CONDITIONAL_PRECENDENCE))
          .append(TERNARY_SEMICOLON);

    if (elseBranch instanceof JSIfStatement) {
        getAssignmentReplacement(buffer,(JSIfStatement) elseBranch);
        return;
    }

    final JSExpressionStatement  strippedElseBranch = (JSExpressionStatement)  ConditionalUtils.stripBraces(elseBranch);
    final JSAssignmentExpression elseAssign         = (JSAssignmentExpression) strippedElseBranch.getExpression();
    final JSExpression           elseRhs            = elseAssign.getROperand();

    assert (elseRhs != null);

    buffer.append(ParenthesesUtils.getParenthesized(elseRhs,ParenthesesUtils.CONDITIONAL_PRECENDENCE));
}

private static JSFunctionExpression getFunctionExpr(final ASTNode statementNode)
{
    return (JSFunctionExpression) ((JSAssignmentExpression) ((JSExpressionStatement) statementNode.getPsi()).getExpression()).getROperand();
}

public static boolean isSimplifiableImplicitAssignment(JSIfStatement ifStatement,boolean negated) {
    if (ifStatement.getElse() != null) {
        return false;
    }
    final Jsstatement  thenBranch    = ConditionalUtils.stripBraces(ifStatement.getThen());
    final PsiElement   nextStatement = JSElementFactory.getNonWhiteSpaceSibling(ifStatement,false);

    if (!(nextStatement instanceof Jsstatement)) {
        return false;
    }

    final Jsstatement elseBranch = ConditionalUtils.stripBraces((Jsstatement) nextStatement);

    final boolean isAssignment;

    if (negated) {
        isAssignment = (ConditionalUtils.isAssignment(thenBranch,elseLhs);
    } else {
        return false;
    }
}

public static boolean statementMayReturnBeforeRecursing(
        Jsstatement statement,JSFunction method) {
    if (statement == null) {
        return true;
    }

    if (statement instanceof JSBreakStatement      ||
        statement instanceof JSContinueStatement   ||
        statement instanceof JSThrowStatement      ||
        statement instanceof JSExpressionStatement ||
        statement instanceof JSEmptyStatement      ||
        statement instanceof JSVarStatement) {
        return false;
    } else if (statement instanceof JSReturnStatement) {
        final JSReturnStatement returnStatement =
                (JSReturnStatement) statement;
        final JSExpression returnValue = returnStatement.getExpression();
        return (returnValue == null ||
                !RecursionUtil.expressionDefinitelyRecurses(returnValue,method));
    } else if (statement instanceof JSForStatement) {
        return RecursionUtil.forStatementMayReturnBeforeRecursing(
                (JSForStatement) statement,method);
    } else if (statement instanceof JSForInStatement) {
        return RecursionUtil.forInStatementMayReturnBeforeRecursing(
                (JSForInStatement) statement,method);
    } else if (statement instanceof JSWhileStatement) {
        return RecursionUtil.whileStatementMayReturnBeforeRecursing(
                (JSWhileStatement) statement,method);
    } else if (statement instanceof JSDoWhileStatement) {
        return RecursionUtil.doWhileStatementMayReturnBeforeRecursing(
                (JSDoWhileStatement) statement,method);
    } else if (statement instanceof JSBlockStatement) {
        final JSBlockStatement blockStatement =
                (JSBlockStatement)statement;
        return RecursionUtil.blockStatementMayReturnBeforeRecursing(blockStatement,method,false);
    } else if (statement instanceof JSLabeledStatement) {
        return RecursionUtil.labeledStatementMayReturnBeforeRecursing(
                (JSLabeledStatement) statement,method);
    } else if (statement instanceof JSIfStatement) {
        return RecursionUtil.ifStatementMayReturnBeforeRecursing(
                (JSIfStatement) statement,method);
    } else if (statement instanceof JSTryStatement) {
        return RecursionUtil.tryStatementMayReturnBeforeRecursing(
                (JSTryStatement) statement,method);
    } else if (statement instanceof JSSwitchStatement) {
        return RecursionUtil.switchStatementMayReturnBeforeRecursing(
                (JSSwitchStatement) statement,method);
    } else {
        // unkNown statement type
        return true;
    }
}

private static boolean statementDefinitelyRecurses(Jsstatement statement,JSFunction method) {
    if (statement == null) {
        return false;
    }
    if (statement instanceof JSBreakStatement    ||
        statement instanceof JSContinueStatement ||
        statement instanceof JSThrowStatement    ||
        statement instanceof JSEmptyStatement) {
        return false;
    } else if (statement instanceof JSExpressionStatement) {
        final JSExpressionStatement expressionStatement =
                (JSExpressionStatement)statement;
        final JSExpression expression =
                expressionStatement.getExpression();
        return RecursionUtil.expressionDefinitelyRecurses(expression,method);
    } else if (statement instanceof JSVarStatement) {
        final JSVarStatement varStatement =
                (JSVarStatement) statement;
        for(final JSVariable variable : varStatement.getvariables()) {
            final JSExpression initializer = variable.getinitializer();
            if (RecursionUtil.expressionDefinitelyRecurses(initializer,method)) {
                return true;
            }
        }
        return false;
    } else if (statement instanceof JSReturnStatement) {
        final JSReturnStatement returnStatement =
                (JSReturnStatement) statement;
        final JSExpression returnValue = returnStatement.getExpression();
        if (returnValue != null) {
            if (RecursionUtil.expressionDefinitelyRecurses(returnValue,method)) {
                return true;
            }
        }
        return false;
    } else if (statement instanceof JSForStatement) {
        return RecursionUtil.forStatementDefinitelyRecurses((JSForStatement)
                statement,method);
    } else if (statement instanceof JSForInStatement) {
        return RecursionUtil.forInStatementDefinitelyRecurses(
                (JSForInStatement) statement,method);
    } else if (statement instanceof JSWhileStatement) {
        return RecursionUtil.whileStatementDefinitelyRecurses(
                (JSWhileStatement) statement,method);
    } else if (statement instanceof JSDoWhileStatement) {
        return RecursionUtil.doWhileStatementDefinitelyRecurses(
                (JSDoWhileStatement) statement,method);
    } else if (statement instanceof JSBlockStatement) {
        return RecursionUtil.blockStatementDefinitelyRecurses(
                (JSBlockStatement) statement,method);
    } else if (statement instanceof JSLabeledStatement) {
        return RecursionUtil.labeledStatementDefinitelyRecurses(
                (JSLabeledStatement) statement,method);
    } else if (statement instanceof JSIfStatement) {
        return RecursionUtil.ifStatementDefinitelyRecurses(
                (JSIfStatement) statement,method);
    } else if (statement instanceof JSTryStatement) {
        return RecursionUtil.tryStatementDefinitelyRecurses(
                (JSTryStatement) statement,method);
    } else if (statement instanceof JSSwitchStatement) {
        return RecursionUtil.switchStatementDefinitelyRecurses(
                (JSSwitchStatement) statement,method);
    } else {
        // unkNown statement type
        return false;
    }
}

@Override
public PsiField createPsi(@NotNull final ASTNode node) {
  if (node instanceof EnumConstantElement) {
    return new PsiEnumConstantImpl(node);
  }
  else {
    return new PsiFieldImpl(node);
  }
}

@Override
public PsiField createPsi(@NotNull final ASTNode node) {
  if (node instanceof EnumConstantElement) {
    return new PsiEnumConstantImpl(node);
  }
  else {
    return new PsiFieldImpl(node);
  }
}

@Override
public PsiField createPsi(@NotNull final ASTNode node)
{
    if(node instanceof EnumConstantElement)
    {
        return new PsiEnumConstantImpl(node);
    }
    else
    {
        return new PsiFieldImpl(node);
    }
}

@Override
public PsiElement getAppropriateParentFrom(PsiElement element) {
  if (element.getLanguage() == JAVA) {
    int hopes = 0;
    while (hopes++ < MAX_HOPES && element != null) {
      if (element instanceof PsiField ||
          element instanceof PsiMethod ||
          element instanceof ImportStatementElement ||
          element instanceof PsiClass
        ) return element;

      element = element.getParent();
    }
  }
  return null;
}

@Override
public PsiElement getAppropriateParentFrom(PsiElement element) {
  if (element.getLanguage() == JAVA) {
    int hopes = 0;
    while (hopes++ < MAX_HOPES && element != null) {
      if (element instanceof PsiField ||
          element instanceof PsiMethod ||
          element instanceof ImportStatementElement ||
          element instanceof PsiClass
        ) return element;

      element = element.getParent();
    }
  }
  return null;
}

@Override
public PsiElement getAppropriateParentFrom(PsiElement element) {
  if (element.getLanguage() == JavaLanguage.INSTANCE) {
    int hopes = 0;
    while (hopes++ < MAX_HOPES && element != null) {
      if (element instanceof PsiField ||
          element instanceof PsiMethod ||
          element instanceof ImportStatementElement ||
          element instanceof PsiClass
        ) return element;

      element = element.getParent();
    }
  }
  return null;
}

@Override
public PsiImportStatementBase createPsi(@NotNull final ASTNode node) {
  if (node instanceof ImportStaticStatementElement) {
    return new PsiImportStaticStatementImpl(node);
  }
  else {
    return new PsiImportStatementImpl(node);
  }
}

@Override
public PsiImportStatementBase createPsi(@NotNull final ASTNode node) {
  if (node instanceof ImportStaticStatementElement) {
    return new PsiImportStaticStatementImpl(node);
  }
  else {
    return new PsiImportStatementImpl(node);
  }
}

@Override
public PsiImportStatementBase createPsi(@NotNull final ASTNode node)
{
    if(node instanceof ImportStaticStatementElement)
    {
        return new PsiImportStaticStatementImpl(node);
    }
    else
    {
        return new PsiImportStatementImpl(node);
    }
}