public void testCommentAtEnd() throws Exception {

    IPackageFragment pack1 = this.sourceFolder.createPackageFragment("test1", false, null);
    StringBuffer buf = new StringBuffer();
    buf.append("function E() \n");
    buf.append("{\n");
    buf.append("}//comment");
    IJavaScriptUnit cu = pack1.createCompilationUnit("E.js", buf.toString(), false, null);

    JavaScriptUnit astRoot = createAST3(cu);
    ASTRewrite rewrite = ASTRewrite.create(astRoot.getAST());

    AST ast = astRoot.getAST();

    assertTrue("Parse errors", (astRoot.getFlags() & ASTNode.MALFORMED) == 0);

    ListRewrite listRewrite = rewrite.getListRewrite(astRoot, JavaScriptUnit.STATEMENTS_PROPERTY);
    FunctionDeclaration newFunction = ast.newFunctionDeclaration();
    newFunction.setName(ast.newSimpleName("B"));
    listRewrite.insertLast(newFunction, null);

    String preview = evaluateRewrite(cu, rewrite);

    buf = new StringBuffer();
    buf.append("function E() \n");
    buf.append("{\n");
    buf.append("}//comment\n");
    buf.append("\n");
    buf.append("function B() {\n");
    buf.append("}");
    assertEqualString(preview, buf.toString());
  }
  public void testBug128818() throws Exception {

    IPackageFragment pack1 = this.sourceFolder.createPackageFragment("test1", false, null);
    StringBuffer buf = new StringBuffer();
    buf.append("function foo() {\n");
    buf.append("  if (true) {\n");
    buf.append("  } // comment\n");
    buf.append("  else\n");
    buf.append("    return;\n");
    buf.append("}\n");
    IJavaScriptUnit cu = pack1.createCompilationUnit("E.js", buf.toString(), false, null);

    JavaScriptUnit astRoot = createAST3(cu);
    ASTRewrite rewrite = ASTRewrite.create(astRoot.getAST());

    AST ast = astRoot.getAST();

    assertTrue("Parse errors", (astRoot.getFlags() & ASTNode.MALFORMED) == 0);
    FunctionDeclaration function = findMethodDeclaration(astRoot, "foo");
    IfStatement statement = (IfStatement) function.getBody().statements().get(0);

    rewrite.set(statement, IfStatement.ELSE_STATEMENT_PROPERTY, ast.newBlock(), null);

    String preview = evaluateRewrite(cu, rewrite);

    buf = new StringBuffer();
    buf.append("function foo() {\n");
    buf.append("  if (true) {\n");
    buf.append("  } // comment\n");
    buf.append(" else {\n");
    buf.append("}\n");
    buf.append("}\n");
    assertEqualString(preview, buf.toString());
  }
  /** @deprecated using deprecated code */
  public void testSimpleName() throws Exception {
    IPackageFragment pack1 = this.sourceFolder.createPackageFragment("test1", false, null);
    StringBuffer buf = new StringBuffer();
    buf.append("    function foo(hello) {\n");
    buf.append("        return hello;\n");
    buf.append("    }\n");
    IJavaScriptUnit cu = pack1.createCompilationUnit("E.js", buf.toString(), false, null);

    JavaScriptUnit astRoot = createAST(cu);
    ASTRewrite rewrite = ASTRewrite.create(astRoot.getAST());

    assertTrue("Parse errors", (astRoot.getFlags() & ASTNode.MALFORMED) == 0);
    //		TypeDeclaration type= findTypeDeclaration(astRoot, "E");

    FunctionDeclaration methodDecl = findMethodDeclaration(astRoot, "foo");
    Block block = methodDecl.getBody();
    List statements = block.statements();
    assertTrue("Number of statements not 1", statements.size() == 1);
    { // replace identifier
      ReturnStatement returnStatement = (ReturnStatement) statements.get(0);

      SimpleName simpleName = (SimpleName) returnStatement.getExpression();
      rewrite.set(simpleName, SimpleName.IDENTIFIER_PROPERTY, "changed", null);
    }

    String preview = evaluateRewrite(cu, rewrite);

    buf = new StringBuffer();
    buf.append("    function foo(hello) {\n");
    buf.append("        return changed;\n");
    buf.append("    }\n");
    assertEqualString(preview, buf.toString());
  }
  /** @deprecated using deprecated code */
  public void testCharacterLiteral() throws Exception {
    IPackageFragment pack1 = this.sourceFolder.createPackageFragment("test1", false, null);
    StringBuffer buf = new StringBuffer();
    buf.append("    function foo() {\n");
    buf.append("        return 'x';\n");
    buf.append("    }\n");
    IJavaScriptUnit cu = pack1.createCompilationUnit("E.js", buf.toString(), false, null);

    JavaScriptUnit astRoot = createAST(cu);
    ASTRewrite rewrite = ASTRewrite.create(astRoot.getAST());

    assertTrue("Parse errors", (astRoot.getFlags() & ASTNode.MALFORMED) == 0);
    //		TypeDeclaration type= findTypeDeclaration(astRoot, "E");

    FunctionDeclaration methodDecl = findMethodDeclaration(astRoot, "foo");
    Block block = methodDecl.getBody();
    List statements = block.statements();
    assertTrue("Number of statements not 1", statements.size() == 1);
    { // replace number
      ReturnStatement returnStatement = (ReturnStatement) statements.get(0);

      StringLiteral literal = (StringLiteral) returnStatement.getExpression();
      rewrite.set(literal, StringLiteral.ESCAPED_VALUE_PROPERTY, "'y'", null);
    }

    String preview = evaluateRewrite(cu, rewrite);

    buf = new StringBuffer();
    buf.append("    function foo() {\n");
    buf.append("        return 'y';\n");
    buf.append("    }\n");
    assertEqualString(preview, buf.toString());
  }
  public void testAssignment() throws Exception {
    IPackageFragment pack1 = this.sourceFolder.createPackageFragment("test1", false, null);
    StringBuffer buf = new StringBuffer();
    buf.append("function foo() {\n");
    buf.append("    var i, j;\n");
    buf.append("    i= 0;\n");
    buf.append("    i-= j= 3;\n");
    buf.append("}\n");
    IJavaScriptUnit cu = pack1.createCompilationUnit("E.js", buf.toString(), false, null);

    JavaScriptUnit astRoot = createAST(cu);
    ASTRewrite rewrite = ASTRewrite.create(astRoot.getAST());

    AST ast = astRoot.getAST();

    assertTrue("Parse errors", (astRoot.getFlags() & ASTNode.MALFORMED) == 0);
    FunctionDeclaration methodDecl = findMethodDeclaration(astRoot, "foo");
    Block block = methodDecl.getBody();
    List statements = block.statements();
    assertTrue("Number of statements not 3", statements.size() == 3);
    { // change left side & right side
      ExpressionStatement stmt = (ExpressionStatement) statements.get(1);
      Assignment assignment = (Assignment) stmt.getExpression();

      SimpleName name = ast.newSimpleName("j");
      rewrite.replace(assignment.getLeftHandSide(), name, null);

      FunctionInvocation invocation = ast.newFunctionInvocation();
      invocation.setName(ast.newSimpleName("goo"));
      invocation.setExpression(ast.newSimpleName("other"));

      rewrite.replace(assignment.getRightHandSide(), invocation, null);
    }
    { // change operator and operator of inner
      ExpressionStatement stmt = (ExpressionStatement) statements.get(2);
      Assignment assignment = (Assignment) stmt.getExpression();

      rewrite.set(
          assignment, Assignment.OPERATOR_PROPERTY, Assignment.Operator.DIVIDE_ASSIGN, null);

      Assignment inner = (Assignment) assignment.getRightHandSide();

      rewrite.set(
          inner,
          Assignment.OPERATOR_PROPERTY,
          Assignment.Operator.RIGHT_SHIFT_UNSIGNED_ASSIGN,
          null);
    }

    String preview = evaluateRewrite(cu, rewrite);

    buf = new StringBuffer();
    buf.append("function foo() {\n");
    buf.append("    var i, j;\n");
    buf.append("    j= other.goo();\n");
    buf.append("    i/= j>>>= 3;\n");
    buf.append("}\n");
    assertEqualString(preview, buf.toString());
  }
 private String getNameDelta(IPackageFragment parent, IPackageFragment fragment) {
   String prefix = parent.getElementName() + '/';
   String fullName = fragment.getElementName();
   if (fullName.startsWith(prefix)) {
     return fullName.substring(prefix.length());
   }
   return fullName;
 }
  public void testRemove() throws Exception {

    IPackageFragment pack1 = this.sourceFolder.createPackageFragment("test1", false, null);

    StringBuffer buf = new StringBuffer();
    buf.append("package test1;//comment Y\n");
    buf.append("public class E//comment Y\n");
    buf.append("{//comment Y\n");
    buf.append("}//comment Y");
    String contents = buf.toString();
    IJavaScriptUnit cu = pack1.createCompilationUnit("E.js", contents, false, null);

    JavaScriptUnit astRoot = createAST3(cu);

    LineCommentEndOffsets offsets = new LineCommentEndOffsets(astRoot.getCommentList());

    int p1 = contents.indexOf('Y') + 1;
    int p2 = contents.indexOf('Y', p1) + 1;
    int p3 = contents.indexOf('Y', p2) + 1;
    int p4 = contents.indexOf('Y', p3) + 1;

    assertFalse(offsets.isEndOfLineComment(0));
    assertTrue(offsets.isEndOfLineComment(p1));
    assertTrue(offsets.isEndOfLineComment(p2));
    assertTrue(offsets.isEndOfLineComment(p3));
    assertTrue(offsets.isEndOfLineComment(p4));

    boolean res = offsets.remove(p2);
    assertTrue(res);

    res = offsets.remove(p2);
    assertFalse(res);

    assertFalse(offsets.isEndOfLineComment(0));
    assertTrue(offsets.isEndOfLineComment(p1));
    assertFalse(offsets.isEndOfLineComment(p2));
    assertTrue(offsets.isEndOfLineComment(p3));
    assertTrue(offsets.isEndOfLineComment(p4));

    res = offsets.remove(p4);
    assertTrue(res);

    assertFalse(offsets.isEndOfLineComment(0));
    assertTrue(offsets.isEndOfLineComment(p1));
    assertFalse(offsets.isEndOfLineComment(p2));
    assertTrue(offsets.isEndOfLineComment(p3));
    assertFalse(offsets.isEndOfLineComment(p4));

    res = offsets.remove(p1);
    assertTrue(res);

    assertFalse(offsets.isEndOfLineComment(0));
    assertFalse(offsets.isEndOfLineComment(p1));
    assertFalse(offsets.isEndOfLineComment(p2));
    assertTrue(offsets.isEndOfLineComment(p3));
    assertFalse(offsets.isEndOfLineComment(p4));
  }
  public void testCatchClause() throws Exception {
    IPackageFragment pack1 = this.sourceFolder.createPackageFragment("test1", false, null);
    StringBuffer buf = new StringBuffer();
    buf.append("function foo() {\n");
    buf.append("    try {\n");
    buf.append("    } catch (e) {\n");
    buf.append("    }\n");
    buf.append("}\n");
    IJavaScriptUnit cu = pack1.createCompilationUnit("E.js", buf.toString(), false, null);

    JavaScriptUnit astRoot = createAST(cu);
    ASTRewrite rewrite = ASTRewrite.create(astRoot.getAST());

    AST ast = astRoot.getAST();

    assertTrue("Parse errors", (astRoot.getFlags() & ASTNode.MALFORMED) == 0);
    FunctionDeclaration methodDecl = findMethodDeclaration(astRoot, "foo");
    Block block = methodDecl.getBody();
    List statements = block.statements();
    assertTrue("Number of statements not 3", statements.size() == 1);
    List catchClauses = ((TryStatement) statements.get(0)).catchClauses();
    assertTrue("Number of catchClauses not 1", catchClauses.size() == 1);
    { // change exception type
      CatchClause clause = (CatchClause) catchClauses.get(0);

      SingleVariableDeclaration exception = clause.getException();

      SingleVariableDeclaration newException = ast.newSingleVariableDeclaration();

      newException.setName(ast.newSimpleName("ex"));

      rewrite.replace(exception, newException, null);
    }
    { // change body
      CatchClause clause = (CatchClause) catchClauses.get(0);
      Block body = clause.getBody();

      Block newBody = ast.newBlock();
      ReturnStatement returnStatement = ast.newReturnStatement();
      newBody.statements().add(returnStatement);

      rewrite.replace(body, newBody, null);
    }

    String preview = evaluateRewrite(cu, rewrite);

    buf = new StringBuffer();
    buf.append("function foo() {\n");
    buf.append("    try {\n");
    buf.append("    } catch (ex) {\n");
    buf.append("        return;\n");
    buf.append("    }\n");
    buf.append("}\n");
    assertEqualString(preview, buf.toString());
  }
 private String getNameDelta(IFolder parent, IPackageFragment fragment) {
   IPath prefix = parent.getFullPath();
   IPath fullPath = fragment.getPath();
   if (prefix.isPrefixOf(fullPath)) {
     StringBuffer buf = new StringBuffer();
     for (int i = prefix.segmentCount(); i < fullPath.segmentCount(); i++) {
       if (buf.length() > 0) buf.append('.');
       buf.append(fullPath.segment(i));
     }
     return buf.toString();
   }
   return fragment.getElementName();
 }
  /** @deprecated using deprecated code */
  public void testMethodInvocation1() throws Exception {
    IPackageFragment pack1 = this.sourceFolder.createPackageFragment("test1", false, null);
    StringBuffer buf = new StringBuffer();
    buf.append("    function foo() {\n");
    buf.append("        foo(foo(1, 2), 3);\n");
    buf.append("    }\n");
    IJavaScriptUnit cu = pack1.createCompilationUnit("E.js", buf.toString(), false, null);

    JavaScriptUnit astRoot = createAST(cu);
    ASTRewrite rewrite = ASTRewrite.create(astRoot.getAST());

    assertTrue("Parse errors", (astRoot.getFlags() & ASTNode.MALFORMED) == 0);
    //		TypeDeclaration type= findTypeDeclaration(astRoot, "E");
    FunctionDeclaration methodDecl = findMethodDeclaration(astRoot, "foo");
    Block block = methodDecl.getBody();
    List statements = block.statements();
    assertTrue("Number of statements not 1", statements.size() == 1);
    { // remove expression, add param, change name
      ExpressionStatement stmt = (ExpressionStatement) statements.get(0);
      FunctionInvocation invocation = (FunctionInvocation) stmt.getExpression();

      List arguments = invocation.arguments();
      FunctionInvocation first = (FunctionInvocation) arguments.get(0);
      ASTNode second = (ASTNode) arguments.get(1);

      ASTNode placeholder1 = rewrite.createCopyTarget(first);
      ASTNode placeholder2 = rewrite.createCopyTarget(second);

      rewrite.replace(first, placeholder2, null);
      rewrite.replace(second, placeholder1, null);

      List innerArguments = first.arguments();
      ASTNode innerFirst = (ASTNode) innerArguments.get(0);
      ASTNode innerSecond = (ASTNode) innerArguments.get(1);

      ASTNode innerPlaceholder1 = rewrite.createCopyTarget(innerFirst);
      ASTNode innerPlaceholder2 = rewrite.createCopyTarget(innerSecond);

      rewrite.replace(innerFirst, innerPlaceholder2, null);
      rewrite.replace(innerSecond, innerPlaceholder1, null);
    }

    String preview = evaluateRewrite(cu, rewrite);

    buf = new StringBuffer();
    buf.append("    function foo() {\n");
    buf.append("        foo(3, foo(2, 1));\n");
    buf.append("    }\n");
    assertEqualString(preview, buf.toString());
  }
  public void testLineCommentEndOffsets() throws Exception {
    IPackageFragment pack1 = this.sourceFolder.createPackageFragment("test1", false, null);

    StringBuffer buf = new StringBuffer();
    buf.append("package test1;\n");
    buf.append("/* comment */\n");
    buf.append("// comment Y\n");
    buf.append("public class E {\n");
    buf.append("    public void foo() {\n");
    buf.append("        while (i == 0) {\n");
    buf.append("            foo();\n");
    buf.append("            i++; // comment Y\n");
    buf.append("            i++;\n");
    buf.append("        }// comment// comment Y\n");
    buf.append("        return;\n");
    buf.append("    }\n");
    buf.append("} // comment Y");
    String content = buf.toString();

    IJavaScriptUnit cu = pack1.createCompilationUnit("E.js", content, false, null);
    JavaScriptUnit astRoot = createAST(cu);

    LineCommentEndOffsets offsets = new LineCommentEndOffsets(astRoot.getCommentList());
    HashSet expectedOffsets = new HashSet();

    for (int i = 0; i < content.length(); i++) {
      char ch = content.charAt(i);
      if (ch == 'Y') {
        expectedOffsets.add(new Integer(i + 1));
      }
    }

    int count = 0;

    char[] charContent = content.toCharArray();
    for (int i = 0; i <= content.length() + 5; i++) {
      boolean expected = i > 0 && i <= content.length() && charContent[i - 1] == 'Y';
      boolean actual = offsets.isEndOfLineComment(i, charContent);
      assertEquals(expected, actual);

      actual = offsets.isEndOfLineComment(i);
      assertEquals(expected, actual);

      if (expected) {
        count++;
      }
    }
    assertEquals(4, count);
  }
  private static boolean hasReadOnlyResourcesAndSubResources(IJavaScriptElement javaElement)
      throws CoreException {
    switch (javaElement.getElementType()) {
      case IJavaScriptElement.CLASS_FILE:
        // if this assert fails, it means that a precondition is missing
        Assert.isTrue(((IClassFile) javaElement).getResource() instanceof IFile);
        // fall thru
      case IJavaScriptElement.JAVASCRIPT_UNIT:
        IResource resource = ReorgUtils.getResource(javaElement);
        return (resource != null && Resources.isReadOnly(resource));
      case IJavaScriptElement.PACKAGE_FRAGMENT:
        IResource packResource = ReorgUtils.getResource(javaElement);
        if (packResource == null) return false;
        IPackageFragment pack = (IPackageFragment) javaElement;
        if (Resources.isReadOnly(packResource)) return true;
        Object[] nonJava = pack.getNonJavaScriptResources();
        for (int i = 0; i < nonJava.length; i++) {
          Object object = nonJava[i];
          if (object instanceof IResource
              && hasReadOnlyResourcesAndSubResources((IResource) object)) return true;
        }
        return hasReadOnlyResourcesAndSubResources(pack.getChildren());
      case IJavaScriptElement.PACKAGE_FRAGMENT_ROOT:
        IPackageFragmentRoot root = (IPackageFragmentRoot) javaElement;
        if (root.isArchive()) return false;
        IResource pfrResource = ReorgUtils.getResource(javaElement);
        if (pfrResource == null) return false;
        if (Resources.isReadOnly(pfrResource)) return true;
        Object[] nonJava1 = root.getNonJavaScriptResources();
        for (int i = 0; i < nonJava1.length; i++) {
          Object object = nonJava1[i];
          if (object instanceof IResource
              && hasReadOnlyResourcesAndSubResources((IResource) object)) return true;
        }
        return hasReadOnlyResourcesAndSubResources(root.getChildren());

      case IJavaScriptElement.FIELD:
      case IJavaScriptElement.IMPORT_CONTAINER:
      case IJavaScriptElement.IMPORT_DECLARATION:
      case IJavaScriptElement.INITIALIZER:
      case IJavaScriptElement.METHOD:
      case IJavaScriptElement.TYPE:
        return false;
      default:
        Assert.isTrue(false); // not handled here
        return false;
    }
  }
  /** @deprecated using deprecated code */
  public void testConditionalExpression() throws Exception {
    IPackageFragment pack1 = this.sourceFolder.createPackageFragment("test1", false, null);
    StringBuffer buf = new StringBuffer();
    buf.append("    function foo() {\n");
    buf.append("        i= (k == 0) ? 1 : 2;\n");
    buf.append("    }\n");
    IJavaScriptUnit cu = pack1.createCompilationUnit("E.js", buf.toString(), false, null);

    JavaScriptUnit astRoot = createAST(cu);
    ASTRewrite rewrite = ASTRewrite.create(astRoot.getAST());

    AST ast = astRoot.getAST();

    assertTrue("Parse errors", (astRoot.getFlags() & ASTNode.MALFORMED) == 0);
    //		TypeDeclaration type= findTypeDeclaration(astRoot, "E");
    FunctionDeclaration methodDecl = findMethodDeclaration(astRoot, "foo");
    Block block = methodDecl.getBody();
    List statements = block.statements();
    assertTrue("Number of statements not 1", statements.size() == 1);
    { // change compare expression, then expression & else expression
      ExpressionStatement stmt = (ExpressionStatement) statements.get(0);
      Assignment assignment = (Assignment) stmt.getExpression();
      ConditionalExpression condExpression = (ConditionalExpression) assignment.getRightHandSide();

      BooleanLiteral literal = ast.newBooleanLiteral(true);
      rewrite.replace(condExpression.getExpression(), literal, null);

      SimpleName newThenExpre = ast.newSimpleName("x");
      rewrite.replace(condExpression.getThenExpression(), newThenExpre, null);

      InfixExpression infixExpression = ast.newInfixExpression();
      infixExpression.setLeftOperand(ast.newNumberLiteral("1"));
      infixExpression.setRightOperand(ast.newNumberLiteral("2"));
      infixExpression.setOperator(InfixExpression.Operator.PLUS);

      rewrite.replace(condExpression.getElseExpression(), infixExpression, null);
    }

    String preview = evaluateRewrite(cu, rewrite);

    buf = new StringBuffer();
    buf.append("    function foo() {\n");
    buf.append("        i= true ? x : 1 + 2;\n");
    buf.append("    }\n");
    assertEqualString(preview, buf.toString());
  }
  public void testArrayAccess() throws Exception {
    IPackageFragment pack1 = this.sourceFolder.createPackageFragment("", false, null);
    StringBuffer buf = new StringBuffer();
    buf.append("function foo(o) {\n");
    buf.append("	o[3 /* comment*/ - 1]= this.o[3 - 1];\n");
    buf.append("}\n");
    buf.append("");
    IJavaScriptUnit cu = pack1.createCompilationUnit("E.js", buf.toString(), false, null);

    JavaScriptUnit astRoot = createAST(cu);
    ASTRewrite rewrite = ASTRewrite.create(astRoot.getAST());

    AST ast = astRoot.getAST();

    assertTrue("Parse errors", (astRoot.getFlags() & ASTNode.MALFORMED) == 0);
    FunctionDeclaration methodDecl = findMethodDeclaration(astRoot, "foo");
    Block block = methodDecl.getBody();
    List statements = block.statements();
    assertTrue("Number of statements not 1", statements.size() == 1);
    { // replace left hand side index, replace right hand side index by left side index
      ExpressionStatement stmt = (ExpressionStatement) statements.get(0);
      Assignment assignment = (Assignment) stmt.getExpression();

      ArrayAccess left = (ArrayAccess) assignment.getLeftHandSide();
      ArrayAccess right = (ArrayAccess) assignment.getRightHandSide();

      NumberLiteral name = ast.newNumberLiteral("1");
      rewrite.replace(left.getIndex(), name, null);

      ASTNode placeHolder = rewrite.createCopyTarget(left.getIndex());
      rewrite.replace(right.getIndex(), placeHolder, null);

      SimpleName newName = ast.newSimpleName("o");
      rewrite.replace(right.getArray(), newName, null);
    }

    String preview = evaluateRewrite(cu, rewrite);

    buf = new StringBuffer();
    buf.append("function foo(o) {\n");
    buf.append("	o[1]= o[3 /* comment*/ - 1];\n");
    buf.append("}\n");

    assertEqualString(preview, buf.toString());
  }
  // TODO fix
  public void XtestThisExpression() throws Exception {
    IPackageFragment pack1 = this.sourceFolder.createPackageFragment("test1", false, null);
    StringBuffer buf = new StringBuffer();
    buf.append("function foo() {\n");
    buf.append("    return this;\n");
    buf.append("    return Outer.this;\n");
    buf.append("}\n");
    IJavaScriptUnit cu = pack1.createCompilationUnit("E.js", buf.toString(), false, null);

    JavaScriptUnit astRoot = createAST(cu);
    ASTRewrite rewrite = ASTRewrite.create(astRoot.getAST());

    AST ast = astRoot.getAST();

    assertTrue("Parse errors", (astRoot.getFlags() & ASTNode.MALFORMED) == 0);

    FunctionDeclaration methodDecl = findMethodDeclaration(astRoot, "foo");
    Block block = methodDecl.getBody();
    List statements = block.statements();
    assertTrue("Number of statements not 2", statements.size() == 2);
    { // add qualifier
      ReturnStatement returnStatement = (ReturnStatement) statements.get(0);

      ThisExpression thisExpression = (ThisExpression) returnStatement.getExpression();

      SimpleName newExpression = ast.newSimpleName("X");
      rewrite.set(thisExpression, ThisExpression.QUALIFIER_PROPERTY, newExpression, null);
    }
    { // remove qualifier
      ReturnStatement returnStatement = (ReturnStatement) statements.get(1);

      ThisExpression thisExpression = (ThisExpression) returnStatement.getExpression();

      rewrite.remove(thisExpression.getQualifier(), null);
    }

    String preview = evaluateRewrite(cu, rewrite);

    buf = new StringBuffer();
    buf.append("    function foo() {\n");
    buf.append("        return X.this;\n");
    buf.append("        return this;\n");
    buf.append("    }\n");
    assertEqualString(preview, buf.toString());
  }
  /** @deprecated using deprecated code */
  public void testFieldAccess() throws Exception {
    IPackageFragment pack1 = this.sourceFolder.createPackageFragment("test1", false, null);
    StringBuffer buf = new StringBuffer();
    buf.append("    function foo() {\n");
    buf.append("        foo().i= goo().i;\n");
    buf.append("    }\n");
    IJavaScriptUnit cu = pack1.createCompilationUnit("E.js", buf.toString(), false, null);

    JavaScriptUnit astRoot = createAST(cu);
    ASTRewrite rewrite = ASTRewrite.create(astRoot.getAST());

    AST ast = astRoot.getAST();

    assertTrue("Parse errors", (astRoot.getFlags() & ASTNode.MALFORMED) == 0);
    //		TypeDeclaration type= findTypeDeclaration(astRoot, "E");
    FunctionDeclaration methodDecl = findMethodDeclaration(astRoot, "foo");
    Block block = methodDecl.getBody();
    List statements = block.statements();
    assertTrue("Number of statements not 1", statements.size() == 1);
    { // replace field expression, replace field name
      ExpressionStatement stmt = (ExpressionStatement) statements.get(0);
      Assignment assignment = (Assignment) stmt.getExpression();
      FieldAccess leftFieldAccess = (FieldAccess) assignment.getLeftHandSide();
      FieldAccess rightFieldAccess = (FieldAccess) assignment.getRightHandSide();

      FunctionInvocation invocation = ast.newFunctionInvocation();
      invocation.setName(ast.newSimpleName("xoo"));
      rewrite.replace(leftFieldAccess.getExpression(), invocation, null);

      SimpleName newName = ast.newSimpleName("x");
      rewrite.replace(leftFieldAccess.getName(), newName, null);

      SimpleName rightHand = ast.newSimpleName("b");
      rewrite.replace(rightFieldAccess.getExpression(), rightHand, null);
    }

    String preview = evaluateRewrite(cu, rewrite);

    buf = new StringBuffer();
    buf.append("    function foo() {\n");
    buf.append("        xoo().x= b.i;\n");
    buf.append("    }\n");
    assertEqualString(preview, buf.toString());
  }
  /** @deprecated using deprecated code */
  public void testPostfixExpression() throws Exception {
    IPackageFragment pack1 = this.sourceFolder.createPackageFragment("test1", false, null);
    StringBuffer buf = new StringBuffer();
    buf.append("    function foo() {\n");
    buf.append("        i= x--;\n");
    buf.append("    }\n");
    IJavaScriptUnit cu = pack1.createCompilationUnit("E.js", buf.toString(), false, null);

    JavaScriptUnit astRoot = createAST(cu);
    ASTRewrite rewrite = ASTRewrite.create(astRoot.getAST());

    AST ast = astRoot.getAST();

    assertTrue("Parse errors", (astRoot.getFlags() & ASTNode.MALFORMED) == 0);
    //		TypeDeclaration type= findTypeDeclaration(astRoot, "E");
    FunctionDeclaration methodDecl = findMethodDeclaration(astRoot, "foo");
    Block block = methodDecl.getBody();
    List statements = block.statements();
    assertTrue("Number of statements not 1", statements.size() == 1);
    { // modify operand and operation
      ExpressionStatement stmt = (ExpressionStatement) statements.get(0);
      Assignment assignment = (Assignment) stmt.getExpression();

      PostfixExpression postExpression = (PostfixExpression) assignment.getRightHandSide();

      NumberLiteral newOperation = ast.newNumberLiteral("10");
      rewrite.replace(postExpression.getOperand(), newOperation, null);

      rewrite.set(
          postExpression,
          PostfixExpression.OPERATOR_PROPERTY,
          PostfixExpression.Operator.INCREMENT,
          null);
    }

    String preview = evaluateRewrite(cu, rewrite);

    buf = new StringBuffer();
    buf.append("    function foo() {\n");
    buf.append("        i= 10++;\n");
    buf.append("    }\n");
    assertEqualString(preview, buf.toString());
  }
  /** @deprecated using deprecated code */
  public void testParenthesizedExpression() throws Exception {
    // System.out.println(getClass().getName()+"::" + getName() +" disabled (bug 23362)");

    IPackageFragment pack1 = this.sourceFolder.createPackageFragment("test1", false, null);
    StringBuffer buf = new StringBuffer();
    buf.append("    function foo() {\n");
    buf.append("        i= (1 + 2) * 3;\n");
    buf.append("    }\n");
    IJavaScriptUnit cu = pack1.createCompilationUnit("E.js", buf.toString(), false, null);

    JavaScriptUnit astRoot = createAST(cu);
    ASTRewrite rewrite = ASTRewrite.create(astRoot.getAST());

    AST ast = astRoot.getAST();

    assertTrue("Parse errors", (astRoot.getFlags() & ASTNode.MALFORMED) == 0);
    //		TypeDeclaration type= findTypeDeclaration(astRoot, "E");
    FunctionDeclaration methodDecl = findMethodDeclaration(astRoot, "foo");
    Block block = methodDecl.getBody();
    List statements = block.statements();
    assertTrue("Number of statements not 1", statements.size() == 1);
    { // replace expression
      ExpressionStatement stmt = (ExpressionStatement) statements.get(0);
      Assignment assignment = (Assignment) stmt.getExpression();

      InfixExpression multiplication = (InfixExpression) assignment.getRightHandSide();

      ParenthesizedExpression parenthesizedExpression =
          (ParenthesizedExpression) multiplication.getLeftOperand();

      SimpleName name = ast.newSimpleName("x");
      rewrite.replace(parenthesizedExpression.getExpression(), name, null);
    }

    String preview = evaluateRewrite(cu, rewrite);

    buf = new StringBuffer();
    buf.append("    function foo() {\n");
    buf.append("        i= (x) * 3;\n");
    buf.append("    }\n");
    assertEqualString(preview, buf.toString());
  }
  public void testBug95839() throws Exception {

    IPackageFragment pack1 = this.sourceFolder.createPackageFragment("test1", false, null);
    StringBuffer buf = new StringBuffer();
    buf.append("function foo() {\n");
    buf.append("  object.method(\n");
    buf.append("    param1, // text about param1\n");
    buf.append("    param2  // text about param2\n");
    buf.append("  );\n");
    buf.append("}\n");
    IJavaScriptUnit cu = pack1.createCompilationUnit("E.js", buf.toString(), false, null);

    JavaScriptUnit astRoot = createAST3(cu);
    ASTRewrite rewrite = ASTRewrite.create(astRoot.getAST());

    AST ast = astRoot.getAST();

    assertTrue("Parse errors", (astRoot.getFlags() & ASTNode.MALFORMED) == 0);
    FunctionDeclaration function = findMethodDeclaration(astRoot, "foo");
    ExpressionStatement statement = (ExpressionStatement) function.getBody().statements().get(0);
    FunctionInvocation inv = (FunctionInvocation) statement.getExpression();

    ListRewrite listRewrite = rewrite.getListRewrite(inv, FunctionInvocation.ARGUMENTS_PROPERTY);
    listRewrite.insertLast(ast.newSimpleName("param3"), null);

    String preview = evaluateRewrite(cu, rewrite);

    buf = new StringBuffer();
    buf.append("function foo() {\n");
    buf.append("  object.method(\n");
    buf.append("    param1, // text about param1\n");
    buf.append("    param2  // text about param2\n");
    buf.append(", param3\n");
    buf.append("  );\n");
    buf.append("}\n");
    assertEqualString(preview, buf.toString());
  }
  private Object[] getPackageContents(IPackageFragment fragment) throws JavaScriptModelException {
    ISourceReference[] sourceRefs;
    if (fragment.getKind() == IPackageFragmentRoot.K_SOURCE) {
      sourceRefs = fragment.getJavaScriptUnits();
    } else {
      IClassFile[] classFiles = fragment.getClassFiles();
      List topLevelClassFile = new ArrayList();
      for (int i = 0; i < classFiles.length; i++) {
        IType type = classFiles[i].getType();
        if (type != null
            && type.getDeclaringType() == null
            && !type.isAnonymous()
            && !type.isLocal()) topLevelClassFile.add(classFiles[i]);
      }
      sourceRefs =
          (ISourceReference[])
              topLevelClassFile.toArray(new ISourceReference[topLevelClassFile.size()]);
    }

    Object[] result = new Object[0];
    for (int i = 0; i < sourceRefs.length; i++)
      result = concatenate(result, removeImportAndPackageDeclarations(getChildren(sourceRefs[i])));
    return concatenate(result, fragment.getNonJavaScriptResources());
  }
  /** Adds all of the openables defined within this package fragment to the list. */
  private void injectAllOpenablesForPackageFragment(
      IPackageFragment packFrag, ArrayList openables) {

    try {
      IPackageFragmentRoot root = (IPackageFragmentRoot) packFrag.getParent();
      int kind = root.getKind();
      if (kind != 0) {
        boolean isSourcePackageFragment = (kind == IPackageFragmentRoot.K_SOURCE);
        if (isSourcePackageFragment) {
          IJavaScriptUnit[] cus = packFrag.getJavaScriptUnits();
          for (int i = 0, length = cus.length; i < length; i++) {
            openables.add(cus[i]);
          }
        } else {
          IClassFile[] classFiles = packFrag.getClassFiles();
          for (int i = 0, length = classFiles.length; i < length; i++) {
            openables.add(classFiles[i]);
          }
        }
      }
    } catch (JavaScriptModelException e) {
      // ignore
    }
  }
  /** @deprecated using deprecated code */
  public void testMethodParamsRenameReorder() throws Exception {
    if (true) return;
    IPackageFragment pack1 = this.sourceFolder.createPackageFragment("test1", false, null);
    StringBuffer buf = new StringBuffer();
    buf.append("    function m( y,  a) {\n");
    buf.append("        m(y, a);\n");
    buf.append("    }\n");
    IJavaScriptUnit cu = pack1.createCompilationUnit("E.js", buf.toString(), false, null);

    JavaScriptUnit astRoot = createAST(cu);
    ASTRewrite rewrite = ASTRewrite.create(astRoot.getAST());

    AST ast = astRoot.getAST();

    assertTrue("Parse errors", (astRoot.getFlags() & ASTNode.MALFORMED) == 0);
    //		TypeDeclaration type= findTypeDeclaration(astRoot, "E");
    FunctionDeclaration methodDecl = findMethodDeclaration(astRoot, "m");
    Block block = methodDecl.getBody();
    List statements = block.statements();
    assertTrue("Number of statements not 1", statements.size() == 1);
    {
      // params
      List params = methodDecl.parameters();
      SingleVariableDeclaration firstParam = (SingleVariableDeclaration) params.get(0);
      SingleVariableDeclaration secondParam = (SingleVariableDeclaration) params.get(1);

      // args
      ExpressionStatement stmt = (ExpressionStatement) statements.get(0);
      FunctionInvocation invocation = (FunctionInvocation) stmt.getExpression();
      List arguments = invocation.arguments();
      SimpleName first = (SimpleName) arguments.get(0);
      SimpleName second = (SimpleName) arguments.get(1);

      // rename args
      SimpleName newFirstArg = methodDecl.getAST().newSimpleName("yyy");
      SimpleName newSecondArg = methodDecl.getAST().newSimpleName("bb");
      rewrite.replace(first, newFirstArg, null);
      rewrite.replace(second, newSecondArg, null);

      // rename params
      SimpleName newFirstName = methodDecl.getAST().newSimpleName("yyy");
      SimpleName newSecondName = methodDecl.getAST().newSimpleName("bb");
      rewrite.replace(firstParam.getName(), newFirstName, null);
      rewrite.replace(secondParam.getName(), newSecondName, null);

      // reoder params
      ASTNode paramplaceholder1 = rewrite.createCopyTarget(firstParam);
      ASTNode paramplaceholder2 = rewrite.createCopyTarget(secondParam);

      rewrite.replace(firstParam, paramplaceholder2, null);
      rewrite.replace(secondParam, paramplaceholder1, null);

      // reorder args
      ASTNode placeholder1 = rewrite.createCopyTarget(first);
      ASTNode placeholder2 = rewrite.createCopyTarget(second);

      rewrite.replace(first, placeholder2, null);
      rewrite.replace(second, placeholder1, null);
    }

    String preview = evaluateRewrite(cu, rewrite);

    buf = new StringBuffer();
    buf.append("    function m(bb, yyy) {\n");
    buf.append("        m(bb, yyy);\n");
    buf.append("    }\n");
    assertEqualString(preview, buf.toString());
  }
  /** @deprecated using deprecated code */
  public void testMethodInvocation() throws Exception {
    IPackageFragment pack1 = this.sourceFolder.createPackageFragment("test1", false, null);
    StringBuffer buf = new StringBuffer();
    buf.append("    function foo() {\n");
    buf.append("        foo(1, 2).goo();\n");
    buf.append("        foo(1, 2).goo();\n");
    buf.append("        foo(1, 2).goo();\n");
    buf.append("    }\n");
    IJavaScriptUnit cu = pack1.createCompilationUnit("E.js", buf.toString(), false, null);

    JavaScriptUnit astRoot = createAST(cu);
    ASTRewrite rewrite = ASTRewrite.create(astRoot.getAST());

    AST ast = astRoot.getAST();

    assertTrue("Parse errors", (astRoot.getFlags() & ASTNode.MALFORMED) == 0);
    //		TypeDeclaration type= findTypeDeclaration(astRoot, "E");
    FunctionDeclaration methodDecl = findMethodDeclaration(astRoot, "foo");
    Block block = methodDecl.getBody();
    List statements = block.statements();
    assertTrue("Number of statements not 3", statements.size() == 3);
    { // remove expression, add param, change name
      ExpressionStatement stmt = (ExpressionStatement) statements.get(0);
      FunctionInvocation invocation = (FunctionInvocation) stmt.getExpression();

      rewrite.remove(invocation.getExpression(), null);

      SimpleName name = ast.newSimpleName("x");
      rewrite.replace(invocation.getName(), name, null);

      ASTNode arg = ast.newNumberLiteral("1");
      rewrite
          .getListRewrite(invocation, FunctionInvocation.ARGUMENTS_PROPERTY)
          .insertLast(arg, null);
    }
    { // insert expression, delete params
      ExpressionStatement stmt = (ExpressionStatement) statements.get(1);
      FunctionInvocation invocation = (FunctionInvocation) stmt.getExpression();

      FunctionInvocation leftInvocation = (FunctionInvocation) invocation.getExpression();

      SimpleName newExpression = ast.newSimpleName("x");
      rewrite.set(leftInvocation, FunctionInvocation.EXPRESSION_PROPERTY, newExpression, null);

      List args = leftInvocation.arguments();
      rewrite.remove((ASTNode) args.get(0), null);
      rewrite.remove((ASTNode) args.get(1), null);
    }
    { // remove expression, add it as parameter
      ExpressionStatement stmt = (ExpressionStatement) statements.get(2);
      FunctionInvocation invocation = (FunctionInvocation) stmt.getExpression();

      ASTNode placeHolder = rewrite.createCopyTarget(invocation.getExpression());

      rewrite.set(invocation, FunctionInvocation.EXPRESSION_PROPERTY, null, null);

      rewrite
          .getListRewrite(invocation, FunctionInvocation.ARGUMENTS_PROPERTY)
          .insertLast(placeHolder, null);
    }

    String preview = evaluateRewrite(cu, rewrite);

    buf = new StringBuffer();
    buf.append("    function foo() {\n");
    buf.append("        x(1);\n");
    buf.append("        x.foo().goo();\n");
    buf.append("        goo(foo(1, 2));\n");
    buf.append("    }\n");
    assertEqualString(preview, buf.toString());
  }
  /** @deprecated using deprecated code */
  public void testInfixExpression() throws Exception {
    IPackageFragment pack1 = this.sourceFolder.createPackageFragment("test1", false, null);
    StringBuffer buf = new StringBuffer();
    buf.append("    function foo() {\n");
    buf.append("        i= 1 + 2;\n");
    buf.append("        j= 1 + 2 + 3 + 4 + 5;\n");
    buf.append("        k= 1 + 2 + 3 + 4 + 5;\n");
    buf.append("    }\n");
    IJavaScriptUnit cu = pack1.createCompilationUnit("E.js", buf.toString(), false, null);

    JavaScriptUnit astRoot = createAST(cu);
    ASTRewrite rewrite = ASTRewrite.create(astRoot.getAST());

    AST ast = astRoot.getAST();

    assertTrue("Parse errors", (astRoot.getFlags() & ASTNode.MALFORMED) == 0);
    //		TypeDeclaration type= findTypeDeclaration(astRoot, "E");
    FunctionDeclaration methodDecl = findMethodDeclaration(astRoot, "foo");
    Block block = methodDecl.getBody();
    List statements = block.statements();
    assertTrue("Number of statements not 3", statements.size() == 3);
    { // change left side & right side & operand
      ExpressionStatement stmt = (ExpressionStatement) statements.get(0);
      Assignment assignment = (Assignment) stmt.getExpression();
      InfixExpression expr = (InfixExpression) assignment.getRightHandSide();

      SimpleName leftOp = ast.newSimpleName("k");
      rewrite.replace(expr.getLeftOperand(), leftOp, null);

      SimpleName rightOp = ast.newSimpleName("j");
      rewrite.replace(expr.getRightOperand(), rightOp, null);

      // change operand
      rewrite.set(expr, InfixExpression.OPERATOR_PROPERTY, InfixExpression.Operator.MINUS, null);
    }

    { // remove an ext. operand, add one and replace one
      ExpressionStatement stmt = (ExpressionStatement) statements.get(1);
      Assignment assignment = (Assignment) stmt.getExpression();
      InfixExpression expr = (InfixExpression) assignment.getRightHandSide();

      List extendedOperands = expr.extendedOperands();
      assertTrue("Number of extendedOperands not 3", extendedOperands.size() == 3);

      rewrite.remove((ASTNode) extendedOperands.get(0), null);

      SimpleName newOp1 = ast.newSimpleName("k");
      rewrite.replace((ASTNode) extendedOperands.get(1), newOp1, null);

      SimpleName newOp2 = ast.newSimpleName("n");
      rewrite
          .getListRewrite(expr, InfixExpression.EXTENDED_OPERANDS_PROPERTY)
          .insertLast(newOp2, null);
    }

    { // change operand
      ExpressionStatement stmt = (ExpressionStatement) statements.get(2);
      Assignment assignment = (Assignment) stmt.getExpression();
      InfixExpression expr = (InfixExpression) assignment.getRightHandSide();

      rewrite.set(expr, InfixExpression.OPERATOR_PROPERTY, InfixExpression.Operator.TIMES, null);
    }

    String preview = evaluateRewrite(cu, rewrite);

    buf = new StringBuffer();
    buf.append("    function foo() {\n");
    buf.append("        i= k - j;\n");
    buf.append("        j= 1 + 2 + k + 5 + n;\n");
    buf.append("        k= 1 * 2 * 3 * 4 * 5;\n");
    buf.append("    }\n");
    assertEqualString(preview, buf.toString());
  }