| /******************************************************************************* |
| * Copyright (c) 2009 xored software, Inc. |
| * |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: |
| * xored software, Inc. - initial API and Implementation (Vladimir Belov) |
| *******************************************************************************/ |
| package org.eclipse.dltk.javascript.parser.tests; |
| |
| import java.util.List; |
| |
| import junit.framework.Assert; |
| |
| import org.eclipse.dltk.ast.ASTNode; |
| import org.eclipse.dltk.javascript.ast.ASTVisitor; |
| import org.eclipse.dltk.javascript.ast.Argument; |
| import org.eclipse.dltk.javascript.ast.ArrayInitializer; |
| import org.eclipse.dltk.javascript.ast.AsteriskExpression; |
| import org.eclipse.dltk.javascript.ast.BinaryOperation; |
| import org.eclipse.dltk.javascript.ast.BooleanLiteral; |
| import org.eclipse.dltk.javascript.ast.BreakStatement; |
| import org.eclipse.dltk.javascript.ast.CallExpression; |
| import org.eclipse.dltk.javascript.ast.CaseClause; |
| import org.eclipse.dltk.javascript.ast.CatchClause; |
| import org.eclipse.dltk.javascript.ast.CommaExpression; |
| import org.eclipse.dltk.javascript.ast.ConditionalOperator; |
| import org.eclipse.dltk.javascript.ast.ConstStatement; |
| import org.eclipse.dltk.javascript.ast.ContinueStatement; |
| import org.eclipse.dltk.javascript.ast.DecimalLiteral; |
| import org.eclipse.dltk.javascript.ast.DefaultClause; |
| import org.eclipse.dltk.javascript.ast.DefaultXmlNamespaceStatement; |
| import org.eclipse.dltk.javascript.ast.DoWhileStatement; |
| import org.eclipse.dltk.javascript.ast.EmptyExpression; |
| import org.eclipse.dltk.javascript.ast.EmptyStatement; |
| import org.eclipse.dltk.javascript.ast.ForEachInStatement; |
| import org.eclipse.dltk.javascript.ast.ForInStatement; |
| import org.eclipse.dltk.javascript.ast.ForStatement; |
| import org.eclipse.dltk.javascript.ast.FunctionStatement; |
| import org.eclipse.dltk.javascript.ast.GetAllChildrenExpression; |
| import org.eclipse.dltk.javascript.ast.GetArrayItemExpression; |
| import org.eclipse.dltk.javascript.ast.GetLocalNameExpression; |
| import org.eclipse.dltk.javascript.ast.GetMethod; |
| import org.eclipse.dltk.javascript.ast.Identifier; |
| import org.eclipse.dltk.javascript.ast.IfStatement; |
| import org.eclipse.dltk.javascript.ast.Keyword; |
| import org.eclipse.dltk.javascript.ast.Keywords; |
| import org.eclipse.dltk.javascript.ast.Label; |
| import org.eclipse.dltk.javascript.ast.LabelledStatement; |
| import org.eclipse.dltk.javascript.ast.NewExpression; |
| import org.eclipse.dltk.javascript.ast.NullExpression; |
| import org.eclipse.dltk.javascript.ast.ObjectInitializer; |
| import org.eclipse.dltk.javascript.ast.ObjectInitializerPart; |
| import org.eclipse.dltk.javascript.ast.ParenthesizedExpression; |
| import org.eclipse.dltk.javascript.ast.PropertyExpression; |
| import org.eclipse.dltk.javascript.ast.PropertyInitializer; |
| import org.eclipse.dltk.javascript.ast.RegExpLiteral; |
| import org.eclipse.dltk.javascript.ast.ReturnStatement; |
| import org.eclipse.dltk.javascript.ast.Script; |
| import org.eclipse.dltk.javascript.ast.SetMethod; |
| import org.eclipse.dltk.javascript.ast.StatementBlock; |
| import org.eclipse.dltk.javascript.ast.StringLiteral; |
| import org.eclipse.dltk.javascript.ast.SwitchComponent; |
| import org.eclipse.dltk.javascript.ast.SwitchStatement; |
| import org.eclipse.dltk.javascript.ast.ThisExpression; |
| import org.eclipse.dltk.javascript.ast.ThrowStatement; |
| import org.eclipse.dltk.javascript.ast.TryStatement; |
| import org.eclipse.dltk.javascript.ast.UnaryOperation; |
| import org.eclipse.dltk.javascript.ast.VariableDeclaration; |
| import org.eclipse.dltk.javascript.ast.VariableStatement; |
| import org.eclipse.dltk.javascript.ast.VoidExpression; |
| import org.eclipse.dltk.javascript.ast.WhileStatement; |
| import org.eclipse.dltk.javascript.ast.WithStatement; |
| import org.eclipse.dltk.javascript.ast.XmlAttributeIdentifier; |
| import org.eclipse.dltk.javascript.ast.XmlExpressionFragment; |
| import org.eclipse.dltk.javascript.ast.XmlFragment; |
| import org.eclipse.dltk.javascript.ast.XmlLiteral; |
| import org.eclipse.dltk.javascript.ast.XmlTextFragment; |
| import org.eclipse.dltk.javascript.ast.YieldOperator; |
| import org.eclipse.dltk.utils.IntList; |
| |
| public class ASTVerifier extends ASTVisitor<Boolean> { |
| |
| private String source; |
| private Script root; |
| |
| public ASTVerifier(Script root, String source) { |
| this.root = root; |
| this.source = source; |
| } |
| |
| public void verify() { |
| visit(root); |
| } |
| |
| private void testChar(char ch, int charAt) { |
| Assert.assertEquals(ch, source.charAt(charAt)); |
| } |
| |
| private void testCharIfExists(char ch, int charAt) { |
| |
| if (charAt > -1) |
| Assert.assertEquals(ch, source.charAt(charAt)); |
| } |
| |
| private void testCharList(char ch, IntList charIndexes) { |
| for (int i = 0; i < charIndexes.size(); i++) { |
| int index = charIndexes.get(i); |
| Assert.assertTrue(index > -1); |
| testChar(ch, index); |
| } |
| } |
| |
| private void testString(String text, int start, int end) { |
| |
| Assert.assertTrue(start >= 0); |
| Assert.assertTrue(end > 0); |
| Assert.assertTrue(end > start); |
| |
| Assert.assertEquals(text, source.substring(start, end)); |
| } |
| |
| private void testKeyword(Keyword node) { |
| testString(node.getKeyword(), node.sourceStart(), node.sourceEnd()); |
| } |
| |
| @Override |
| public Boolean visit(ASTNode node) { |
| if (node != null) { |
| Assert.assertTrue(node.getClass().getSimpleName() |
| + " sourceEnd >= sourceStart", |
| node.sourceEnd() >= node.sourceStart()); |
| } |
| return super.visit(node); |
| } |
| |
| @Override |
| public Boolean visitArrayInitializer(ArrayInitializer node) { |
| |
| testCharList(Keywords.COMMA, node.getCommas()); |
| visit(node.getItems()); |
| testChar(Keywords.LB, node.getLB()); |
| testChar(Keywords.RB, node.getRB()); |
| |
| return true; |
| } |
| |
| @Override |
| public Boolean visitBinaryOperation(BinaryOperation node) { |
| |
| testString(node.getOperationText(), node.getOperationPosition(), |
| node.getOperationPosition() + node.getOperationText().length()); |
| |
| visit(node.getLeftExpression()); |
| visit(node.getRightExpression()); |
| |
| return true; |
| } |
| |
| @Override |
| public Boolean visitBooleanLiteral(BooleanLiteral node) { |
| |
| testString(node.getText(), node.sourceStart(), node.sourceEnd()); |
| |
| return true; |
| } |
| |
| @Override |
| public Boolean visitBreakStatement(BreakStatement node) { |
| |
| testKeyword(node.getBreakKeyword()); |
| testLabel(node.getLabel()); |
| testCharIfExists(Keywords.SEMI, node.getSemicolonPosition()); |
| |
| return true; |
| } |
| |
| @Override |
| public Boolean visitCallExpression(CallExpression node) { |
| |
| visit(node.getExpression()); |
| visit(node.getArguments()); |
| |
| testChar(Keywords.LP, node.getLP()); |
| testCharIfExists(Keywords.RP, node.getRP()); |
| testCharList(Keywords.COMMA, node.getCommas()); |
| |
| return true; |
| } |
| |
| @Override |
| public Boolean visitCommaExpression(CommaExpression node) { |
| |
| testCharList(Keywords.COMMA, node.getCommas()); |
| visit(node.getItems()); |
| |
| return true; |
| } |
| |
| @Override |
| public Boolean visitConditionalOperator(ConditionalOperator node) { |
| |
| visit(node.getCondition()); |
| visit(node.getTrueValue()); |
| visit(node.getFalseValue()); |
| |
| testChar(Keywords.COLON, node.getColonPosition()); |
| testChar(Keywords.HOOK, node.getQuestionPosition()); |
| |
| return true; |
| } |
| |
| @Override |
| public Boolean visitConstDeclaration(ConstStatement node) { |
| testKeyword(node.getConstKeyword()); |
| visitVariableDeclarations(node.getVariables()); |
| |
| testChar(Keywords.SEMI, node.getSemicolonPosition()); |
| |
| return true; |
| } |
| |
| @Override |
| public Boolean visitContinueStatement(ContinueStatement node) { |
| |
| testKeyword(node.getContinueKeyword()); |
| testLabel(node.getLabel()); |
| testCharIfExists(Keywords.SEMI, node.getSemicolonPosition()); |
| |
| return true; |
| } |
| |
| @Override |
| public Boolean visitDecimalLiteral(DecimalLiteral node) { |
| |
| testString(node.getText(), node.sourceStart(), node.sourceEnd()); |
| |
| return true; |
| } |
| |
| @Override |
| public Boolean visitDoWhileStatement(DoWhileStatement node) { |
| |
| testKeyword(node.getDoKeyword()); |
| visit(node.getBody()); |
| testKeyword(node.getWhileKeyword()); |
| visit(node.getCondition()); |
| |
| testChar(Keywords.LP, node.getLP()); |
| testChar(Keywords.RP, node.getRP()); |
| testChar(Keywords.SEMI, node.getSemicolonPosition()); |
| |
| return true; |
| } |
| |
| @Override |
| public Boolean visitEmptyExpression(EmptyExpression node) { |
| |
| // Assert.assertTrue(node.sourceStart() < 0); |
| // Assert.assertTrue(node.sourceEnd() < 0); |
| |
| return true; |
| } |
| |
| @Override |
| public Boolean visitForEachInStatement(ForEachInStatement node) { |
| |
| testKeyword(node.getForKeyword()); |
| testKeyword(node.getEachKeyword()); |
| |
| if (node.getBody() != null) |
| node.getBody(); |
| |
| visit(node.getItem()); |
| testKeyword(node.getInKeyword()); |
| visit(node.getIterator()); |
| |
| testChar(Keywords.LP, node.getLP()); |
| testChar(Keywords.RP, node.getRP()); |
| |
| return true; |
| } |
| |
| @Override |
| public Boolean visitGetArrayItemExpression(GetArrayItemExpression node) { |
| |
| visit(node.getArray()); |
| visit(node.getIndex()); |
| |
| testChar(Keywords.LB, node.getLB()); |
| testChar(Keywords.RB, node.getRB()); |
| |
| return true; |
| } |
| |
| private void testGetMethod(GetMethod node) { |
| visit(node.getName()); |
| testKeyword(node.getGetKeyword()); |
| visit(node.getBody()); |
| testChar(Keywords.LP, node.getLP()); |
| testChar(Keywords.RP, node.getRP()); |
| } |
| |
| @Override |
| public Boolean visitIdentifier(Identifier node) { |
| |
| testString(node.getName(), node.sourceStart(), node.sourceEnd()); |
| |
| return true; |
| } |
| |
| @Override |
| public Boolean visitIfStatement(IfStatement node) { |
| |
| testKeyword(node.getIfKeyword()); |
| visit(node.getCondition()); |
| visit(node.getThenStatement()); |
| if (node.getElseStatement() != null) { |
| testKeyword(node.getElseKeyword()); |
| visit(node.getElseStatement()); |
| } |
| testChar(Keywords.LP, node.getLP()); |
| testChar(Keywords.RP, node.getRP()); |
| |
| return true; |
| } |
| |
| private void testLabel(Label node) { |
| if (node != null) { |
| testString(node.getText(), node.sourceStart(), node.sourceEnd()); |
| } |
| } |
| |
| @Override |
| public Boolean visitLabelledStatement(LabelledStatement node) { |
| |
| testLabel(node.getLabel()); |
| testChar(Keywords.COLON, node.getColonPosition()); |
| visit(node.getStatement()); |
| |
| return true; |
| } |
| |
| @Override |
| public Boolean visitNewExpression(NewExpression node) { |
| |
| testKeyword(node.getNewKeyword()); |
| visit(node.getObjectClass()); |
| |
| return true; |
| } |
| |
| @Override |
| public Boolean visitNullExpression(NullExpression node) { |
| |
| testString(node.getText(), node.sourceStart(), node.sourceEnd()); |
| |
| return true; |
| } |
| |
| @Override |
| public Boolean visitObjectInitializer(ObjectInitializer node) { |
| |
| testCharList(Keywords.COMMA, node.getCommas()); |
| for (ObjectInitializerPart part : node.getInitializers()) { |
| if (part instanceof GetMethod) { |
| testGetMethod((GetMethod) part); |
| } else if (part instanceof SetMethod) { |
| testSetMethod((SetMethod) part); |
| } else if (part instanceof PropertyInitializer) { |
| testPropertyInitializer((PropertyInitializer) part); |
| } else { |
| Assert.fail(part.getClass().getName()); |
| } |
| } |
| testChar(Keywords.LC, node.getLC()); |
| testChar(Keywords.RC, node.getRC()); |
| |
| return true; |
| } |
| |
| @Override |
| public Boolean visitParenthesizedExpression(ParenthesizedExpression node) { |
| |
| visit(node.getExpression()); |
| |
| testChar(Keywords.LP, node.getLP()); |
| testChar(Keywords.RP, node.getRP()); |
| |
| return true; |
| } |
| |
| @Override |
| public Boolean visitPropertyExpression(PropertyExpression node) { |
| |
| testChar(Keywords.DOT, node.getDotPosition()); |
| |
| visit(node.getObject()); |
| visit(node.getProperty()); |
| |
| return true; |
| } |
| |
| private void testPropertyInitializer(PropertyInitializer node) { |
| testChar(Keywords.COLON, node.getColon()); |
| |
| visit(node.getName()); |
| visit(node.getValue()); |
| } |
| |
| @Override |
| public Boolean visitRegExpLiteral(RegExpLiteral node) { |
| |
| testString(node.getText(), node.sourceStart(), node.sourceEnd()); |
| |
| return true; |
| } |
| |
| @Override |
| public Boolean visitReturnStatement(ReturnStatement node) { |
| |
| testKeyword(node.getReturnKeyword()); |
| |
| if (node.getValue() != null) |
| visit(node.getValue()); |
| |
| testCharIfExists(Keywords.SEMI, node.getSemicolonPosition()); |
| |
| return true; |
| } |
| |
| @Override |
| public Boolean visitScript(Script node) { |
| |
| Assert.assertEquals(0, node.sourceStart()); |
| Assert.assertEquals(source.length(), node.sourceEnd()); |
| |
| visit(node.getStatements()); |
| return true; |
| } |
| |
| private void testSetMethod(SetMethod node) { |
| testKeyword(node.getSetKeyword()); |
| visit(node.getName()); |
| visit(node.getArgument()); |
| visit(node.getBody()); |
| |
| testChar(Keywords.LP, node.getLP()); |
| testChar(Keywords.RP, node.getRP()); |
| } |
| |
| @Override |
| public Boolean visitStatementBlock(StatementBlock node) { |
| |
| testChar(Keywords.LC, node.getLC()); |
| testChar(Keywords.RC, node.getRC()); |
| |
| visit(node.getStatements()); |
| |
| return true; |
| } |
| |
| @Override |
| public Boolean visitStringLiteral(StringLiteral node) { |
| |
| testString(node.getText(), node.sourceStart(), node.sourceEnd()); |
| |
| return true; |
| } |
| |
| @Override |
| public Boolean visitSwitchStatement(SwitchStatement node) { |
| |
| visit(node.getCondition()); |
| for (SwitchComponent component : node.getCaseClauses()) { |
| if (component instanceof CaseClause) { |
| final CaseClause caseClause = (CaseClause) component; |
| testKeyword(caseClause.getCaseKeyword()); |
| visit(caseClause.getCondition()); |
| testChar(Keywords.COLON, caseClause.getColonPosition()); |
| visit(caseClause.getStatements()); |
| } else { |
| final DefaultClause defaultClause = (DefaultClause) component; |
| testKeyword(defaultClause.getDefaultKeyword()); |
| testChar(Keywords.COLON, defaultClause.getColonPosition()); |
| visit(defaultClause.getStatements()); |
| } |
| } |
| |
| testChar(Keywords.LC, node.getLC()); |
| testChar(Keywords.RC, node.getRC()); |
| testChar(Keywords.LP, node.getLP()); |
| testChar(Keywords.RP, node.getRP()); |
| |
| return true; |
| } |
| |
| @Override |
| public Boolean visitThisExpression(ThisExpression node) { |
| |
| testString(Keywords.THIS, node.sourceStart(), node.sourceEnd()); |
| |
| return true; |
| } |
| |
| @Override |
| public Boolean visitThrowStatement(ThrowStatement node) { |
| |
| testKeyword(node.getThrowKeyword()); |
| visit(node.getException()); |
| |
| if (node.getSemicolonPosition() > 0) |
| testChar(Keywords.SEMI, node.getSemicolonPosition()); |
| |
| return true; |
| } |
| |
| @Override |
| public Boolean visitTryStatement(TryStatement node) { |
| |
| testKeyword(node.getTryKeyword()); |
| visit(node.getBody()); |
| for (CatchClause catchClause : node.getCatches()) { |
| testKeyword(catchClause.getCatchKeyword()); |
| visit(catchClause.getException()); |
| if (catchClause.getIfKeyword() != null) { |
| testKeyword(catchClause.getIfKeyword()); |
| } |
| if (catchClause.getFilterExpression() != null) { |
| visit(catchClause.getFilterExpression()); |
| } |
| visit(catchClause.getStatement()); |
| |
| testChar(Keywords.LP, catchClause.getLP()); |
| testChar(Keywords.RP, catchClause.getRP()); |
| } |
| |
| if (node.getFinally() != null) { |
| testKeyword(node.getFinally().getFinallyKeyword()); |
| visit(node.getFinally().getStatement()); |
| } |
| |
| return true; |
| } |
| |
| @Override |
| public Boolean visitUnaryOperation(UnaryOperation node) { |
| |
| visit(node.getExpression()); |
| |
| testString(node.getOperationText(), node.getOperationPosition(), |
| node.getOperationPosition() + node.getOperationText().length()); |
| |
| return true; |
| } |
| |
| @Override |
| public Boolean visitVariableStatement(VariableStatement node) { |
| |
| testKeyword(node.getVarKeyword()); |
| visitVariableDeclarations(node.getVariables()); |
| |
| return true; |
| } |
| |
| private void visitVariableDeclarations( |
| List<VariableDeclaration> declarations) { |
| for (VariableDeclaration declaration : declarations) { |
| visit(declaration.getIdentifier()); |
| if (declaration.getInitializer() != null) { |
| visit(declaration.getInitializer()); |
| } |
| if (declaration.getColonPosition() != -1) { |
| testChar(':', declaration.getColonPosition()); |
| } |
| if (declaration.getAssignPosition() != -1) { |
| testChar('=', declaration.getAssignPosition()); |
| } |
| if (declaration.getCommaPosition() != -1) { |
| testChar(',', declaration.getCommaPosition()); |
| } |
| } |
| } |
| |
| @Override |
| public Boolean visitVoidExpression(VoidExpression node) { |
| |
| testCharIfExists(Keywords.SEMI, node.getSemicolonPosition()); |
| |
| visit(node.getExpression()); |
| |
| return true; |
| } |
| |
| @Override |
| public Boolean visitWhileStatement(WhileStatement node) { |
| |
| testKeyword(node.getWhileKeyword()); |
| visit(node.getCondition()); |
| |
| if (node.getBody() != null) |
| visit(node.getBody()); |
| |
| testChar(Keywords.LP, node.getLP()); |
| testChar(Keywords.RP, node.getRP()); |
| |
| return true; |
| } |
| |
| @Override |
| public Boolean visitWithStatement(WithStatement node) { |
| |
| testChar(Keywords.LP, node.getLP()); |
| testChar(Keywords.RP, node.getRP()); |
| |
| testKeyword(node.getWithKeyword()); |
| visit(node.getExpression()); |
| visit(node.getStatement()); |
| |
| return true; |
| } |
| |
| @Override |
| public Boolean visitForInStatement(ForInStatement node) { |
| |
| testKeyword(node.getForKeyword()); |
| |
| if (node.getBody() != null) |
| node.getBody(); |
| |
| visit(node.getItem()); |
| testKeyword(node.getInKeyword()); |
| visit(node.getIterator()); |
| |
| testChar(Keywords.LP, node.getLP()); |
| testChar(Keywords.RP, node.getRP()); |
| |
| return true; |
| } |
| |
| @Override |
| public Boolean visitFunctionStatement(FunctionStatement node) { |
| |
| testKeyword(node.getFunctionKeyword()); |
| for (Argument argument : node.getArguments()) { |
| visit(argument.getIdentifier()); |
| if (argument.getCommaPosition() != -1) { |
| testChar(',', argument.getCommaPosition()); |
| } |
| } |
| visit(node.getBody()); |
| |
| if (node.getName() != null) |
| visit(node.getName()); |
| |
| testChar(Keywords.LP, node.getLP()); |
| testChar(Keywords.RP, node.getRP()); |
| |
| return true; |
| } |
| |
| @Override |
| public Boolean visitForStatement(ForStatement node) { |
| |
| testKeyword(node.getForKeyword()); |
| |
| visit(node.getInitial()); |
| visit(node.getCondition()); |
| visit(node.getStep()); |
| |
| if (node.getBody() != null) |
| visit(node.getBody()); |
| |
| final int initSC = node.getInitialSemicolonPosition(); |
| final int condSC = node.getConditionalSemicolonPosition(); |
| final int lp = node.getLP(); |
| final int rp = node.getRP(); |
| Assert.assertTrue(lp < initSC); |
| Assert.assertTrue("initialSemicolonPosition:" + initSC |
| + " conditionalSemicolonPosition:" + condSC, initSC < condSC); |
| Assert.assertTrue(condSC < rp); |
| testChar(Keywords.SEMI, condSC); |
| testChar(Keywords.SEMI, initSC); |
| testChar(Keywords.LP, lp); |
| testChar(Keywords.RP, rp); |
| |
| return true; |
| } |
| |
| @Override |
| public Boolean visitXmlLiteral(XmlLiteral node) { |
| for (XmlFragment fragment : node.getFragments()) { |
| if (fragment instanceof XmlTextFragment) { |
| XmlTextFragment textFragment = (XmlTextFragment) fragment; |
| testString(textFragment.getXml(), fragment.sourceStart(), |
| fragment.sourceEnd()); |
| } else { |
| XmlExpressionFragment expression = (XmlExpressionFragment) fragment; |
| visit(expression.getExpression()); |
| // TODO curly braces |
| } |
| } |
| return true; |
| } |
| |
| @Override |
| public Boolean visitDefaultXmlNamespace(DefaultXmlNamespaceStatement node) { |
| |
| testKeyword(node.getDefaultKeyword()); |
| testKeyword(node.getXmlKeyword()); |
| testKeyword(node.getNamespaceKeyword()); |
| |
| testChar(Keywords.ASSIGN, node.getAssignOperation()); |
| testCharIfExists(Keywords.SEMI, node.getSemicolonPosition()); |
| |
| return true; |
| } |
| |
| @Override |
| public Boolean visitAsteriskExpression(AsteriskExpression node) { |
| // TODO Auto-generated method stub |
| return false; |
| } |
| |
| @Override |
| public Boolean visitGetAllChildrenExpression(GetAllChildrenExpression node) { |
| // TODO Auto-generated method stub |
| return false; |
| } |
| |
| @Override |
| public Boolean visitGetLocalNameExpression(GetLocalNameExpression node) { |
| // TODO Auto-generated method stub |
| return false; |
| } |
| |
| @Override |
| public Boolean visitXmlPropertyIdentifier(XmlAttributeIdentifier node) { |
| // TODO Auto-generated method stub |
| return false; |
| } |
| |
| @Override |
| public Boolean visitYieldOperator(YieldOperator node) { |
| // TODO Auto-generated method stub |
| return false; |
| } |
| |
| @Override |
| public Boolean visitEmptyStatement(EmptyStatement node) { |
| testChar(';', node.sourceStart()); |
| return false; |
| } |
| |
| } |
