/*******************************************************************************
* Copyright (c) 2004, 2009 IBM Corporation and others.
* 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:
* IBM Corporation - initial API and implementation
*******************************************************************************/
package org.eclipse.wst.jsdt.core.tests.dom;
import java.util.ArrayList;
import java.util.List;
import org.eclipse.wst.jsdt.core.dom.AST;
import org.eclipse.wst.jsdt.core.dom.ASTNode;
import org.eclipse.wst.jsdt.core.dom.AnonymousClassDeclaration;
import org.eclipse.wst.jsdt.core.dom.ArrayAccess;
import org.eclipse.wst.jsdt.core.dom.ArrayCreation;
import org.eclipse.wst.jsdt.core.dom.ArrayInitializer;
import org.eclipse.wst.jsdt.core.dom.ArrayType;
import org.eclipse.wst.jsdt.core.dom.Assignment;
import org.eclipse.wst.jsdt.core.dom.Block;
import org.eclipse.wst.jsdt.core.dom.BooleanLiteral;
import org.eclipse.wst.jsdt.core.dom.BreakStatement;
import org.eclipse.wst.jsdt.core.dom.CatchClause;
import org.eclipse.wst.jsdt.core.dom.CharacterLiteral;
import org.eclipse.wst.jsdt.core.dom.ClassInstanceCreation;
import org.eclipse.wst.jsdt.core.dom.ConditionalExpression;
import org.eclipse.wst.jsdt.core.dom.ConstructorInvocation;
import org.eclipse.wst.jsdt.core.dom.ContinueStatement;
import org.eclipse.wst.jsdt.core.dom.DoStatement;
import org.eclipse.wst.jsdt.core.dom.EmptyStatement;
import org.eclipse.wst.jsdt.core.dom.EnhancedForStatement;
import org.eclipse.wst.jsdt.core.dom.ExpressionStatement;
import org.eclipse.wst.jsdt.core.dom.FieldAccess;
import org.eclipse.wst.jsdt.core.dom.FieldDeclaration;
import org.eclipse.wst.jsdt.core.dom.ForStatement;
import org.eclipse.wst.jsdt.core.dom.FunctionDeclaration;
import org.eclipse.wst.jsdt.core.dom.FunctionInvocation;
import org.eclipse.wst.jsdt.core.dom.FunctionRef;
import org.eclipse.wst.jsdt.core.dom.IfStatement;
import org.eclipse.wst.jsdt.core.dom.ImportDeclaration;
import org.eclipse.wst.jsdt.core.dom.InfixExpression;
import org.eclipse.wst.jsdt.core.dom.Initializer;
import org.eclipse.wst.jsdt.core.dom.InstanceofExpression;
import org.eclipse.wst.jsdt.core.dom.JSdoc;
import org.eclipse.wst.jsdt.core.dom.JavaScriptUnit;
import org.eclipse.wst.jsdt.core.dom.LabeledStatement;
import org.eclipse.wst.jsdt.core.dom.Name;
import org.eclipse.wst.jsdt.core.dom.NullLiteral;
import org.eclipse.wst.jsdt.core.dom.NumberLiteral;
import org.eclipse.wst.jsdt.core.dom.PackageDeclaration;
import org.eclipse.wst.jsdt.core.dom.ParenthesizedExpression;
import org.eclipse.wst.jsdt.core.dom.PostfixExpression;
import org.eclipse.wst.jsdt.core.dom.PrefixExpression;
import org.eclipse.wst.jsdt.core.dom.PrimitiveType;
import org.eclipse.wst.jsdt.core.dom.QualifiedName;
import org.eclipse.wst.jsdt.core.dom.QualifiedType;
import org.eclipse.wst.jsdt.core.dom.ReturnStatement;
import org.eclipse.wst.jsdt.core.dom.SimpleName;
import org.eclipse.wst.jsdt.core.dom.SimpleType;
import org.eclipse.wst.jsdt.core.dom.SingleVariableDeclaration;
import org.eclipse.wst.jsdt.core.dom.StringLiteral;
import org.eclipse.wst.jsdt.core.dom.SuperConstructorInvocation;
import org.eclipse.wst.jsdt.core.dom.SuperFieldAccess;
import org.eclipse.wst.jsdt.core.dom.SuperMethodInvocation;
import org.eclipse.wst.jsdt.core.dom.SwitchCase;
import org.eclipse.wst.jsdt.core.dom.SwitchStatement;
import org.eclipse.wst.jsdt.core.dom.TagElement;
import org.eclipse.wst.jsdt.core.dom.ThisExpression;
import org.eclipse.wst.jsdt.core.dom.ThrowStatement;
import org.eclipse.wst.jsdt.core.dom.TryStatement;
import org.eclipse.wst.jsdt.core.dom.TypeDeclaration;
import org.eclipse.wst.jsdt.core.dom.TypeDeclarationStatement;
import org.eclipse.wst.jsdt.core.dom.TypeLiteral;
import org.eclipse.wst.jsdt.core.dom.VariableDeclarationExpression;
import org.eclipse.wst.jsdt.core.dom.VariableDeclarationFragment;
import org.eclipse.wst.jsdt.core.dom.VariableDeclarationStatement;
import org.eclipse.wst.jsdt.core.dom.WhileStatement;
public class SampleASTs {
/**
* Returns a subtree of sample of AST nodes. The sample includes
* one of each kind (except for BlockComment and LineComment,
* which cannot be connected directly to a JavaScriptUnit),
* but otherwise does not make sense.
*/
public static ASTNode oneOfEach(AST target) {
JavaScriptUnit cu = target.newJavaScriptUnit();
PackageDeclaration pd = target.newPackageDeclaration();
cu.setPackage(pd);
ImportDeclaration im = target.newImportDeclaration();
cu.imports().add(im);
TypeDeclaration td = target.newTypeDeclaration();
cu.types().add(td);
JSdoc javadoc = target.newJSdoc();
td.setJavadoc(javadoc);
TagElement tg = target.newTagElement();
javadoc.tags().add(tg);
tg.fragments().add(target.newTextElement());
tg.fragments().add(target.newMemberRef());
FunctionRef mr = target.newFunctionRef();
tg.fragments().add(mr);
mr.parameters().add(target.newFunctionRefParameter());
VariableDeclarationFragment variableDeclarationFragment = target.newVariableDeclarationFragment();
FieldDeclaration fd =
target.newFieldDeclaration(variableDeclarationFragment);
td.bodyDeclarations().add(fd);
Initializer in = target.newInitializer();
td.bodyDeclarations().add(in);
FunctionDeclaration md = target.newFunctionDeclaration();
SingleVariableDeclaration singleVariableDeclaration = target.newSingleVariableDeclaration();
md.parameters().add(singleVariableDeclaration);
td.bodyDeclarations().add(md);
SimpleName sn1 = target.newSimpleName("one"); //$NON-NLS-1$
SimpleName sn2 =target.newSimpleName("two"); //$NON-NLS-1$
QualifiedName qn = target.newQualifiedName(sn1, sn2);
PrimitiveType pt = target.newPrimitiveType(PrimitiveType.INT);
ArrayType at = target.newArrayType(pt);
fd.setType(at);
if (target.apiLevel() >= AST.JLS3) {
SimpleType st = target.newSimpleType(qn);
QualifiedType qt = target.newQualifiedType(st, target.newSimpleName("x")); //$NON-NLS-1$
}
Block b = target.newBlock();
md.setBody(b);
// all statements (in alphabetic order of statement type)
Block block = target.newBlock();
b.statements().add(block);
BreakStatement breakStatement = target.newBreakStatement();
b.statements().add(breakStatement);
ContinueStatement continueStatement = target.newContinueStatement();
b.statements().add(continueStatement);
ConstructorInvocation constructorInvocation = target.newConstructorInvocation();
b.statements().add(constructorInvocation);
DoStatement doStatement = target.newDoStatement();
b.statements().add(doStatement);
EmptyStatement emptyStatement = target.newEmptyStatement();
b.statements().add(emptyStatement);
NullLiteral nullLiteral = target.newNullLiteral();
ExpressionStatement expressionStatement = target.newExpressionStatement(nullLiteral);
b.statements().add(expressionStatement);
ForStatement forStatement = target.newForStatement();
b.statements().add(forStatement);
if (target.apiLevel() >= AST.JLS3) {
EnhancedForStatement foreachStatement = target.newEnhancedForStatement();
b.statements().add(foreachStatement);
}
IfStatement ifStatement = target.newIfStatement();
b.statements().add(ifStatement);
LabeledStatement labeledStatement = target.newLabeledStatement();
b.statements().add(labeledStatement);
ReturnStatement returnStatement = target.newReturnStatement();
b.statements().add(returnStatement);
SuperConstructorInvocation superConstructorInvocation = target.newSuperConstructorInvocation();
b.statements().add(superConstructorInvocation);
SwitchStatement ss = target.newSwitchStatement();
SwitchCase switchCase = target.newSwitchCase();
ss.statements().add(switchCase);
b.statements().add(ss);
SwitchStatement switchStatement = target.newSwitchStatement();
b.statements().add(switchStatement);
SwitchCase switchCase2 = target.newSwitchCase();
b.statements().add(switchCase2);
ThrowStatement throwStatement = target.newThrowStatement();
b.statements().add(throwStatement);
TryStatement tr = target.newTryStatement();
CatchClause catchClause = target.newCatchClause();
tr.catchClauses().add(catchClause);
b.statements().add(tr);
TypeDeclaration typeDeclaration = target.newTypeDeclaration();
TypeDeclarationStatement typeDeclarationStatement = target.newTypeDeclarationStatement(typeDeclaration);
b.statements().add(typeDeclarationStatement);
VariableDeclarationFragment variableDeclarationFragment2 = target.newVariableDeclarationFragment();
VariableDeclarationStatement variableDeclarationStatement = target.newVariableDeclarationStatement(variableDeclarationFragment2);
b.statements().add(variableDeclarationStatement);
WhileStatement whileStatement = target.newWhileStatement();
b.statements().add(whileStatement);
// all expressions (in alphabetic order of expressions type)
FunctionInvocation inv = target.newFunctionInvocation();
ExpressionStatement expressionStatement2 = target.newExpressionStatement(inv);
b.statements().add(expressionStatement2);
List z = inv.arguments();
ArrayAccess arrayAccess = target.newArrayAccess();
z.add(arrayAccess);
ArrayCreation arrayCreation = target.newArrayCreation();
z.add(arrayCreation);
ArrayInitializer arrayInitializer = target.newArrayInitializer();
z.add(arrayInitializer);
Assignment assignment = target.newAssignment();
z.add(assignment);
BooleanLiteral booleanLiteral = target.newBooleanLiteral(true);
z.add(booleanLiteral);
CharacterLiteral characterLiteral = target.newCharacterLiteral();
z.add(characterLiteral);
ClassInstanceCreation cic = target.newClassInstanceCreation();
AnonymousClassDeclaration anonymousClassDeclaration = target.newAnonymousClassDeclaration();
cic.setAnonymousClassDeclaration(anonymousClassDeclaration);
z.add(cic);
ConditionalExpression conditionalExpression = target.newConditionalExpression();
z.add(conditionalExpression);
FieldAccess fieldAccess = target.newFieldAccess();
z.add(fieldAccess);
InfixExpression infixExpression = target.newInfixExpression();
z.add(infixExpression);
InstanceofExpression instanceofExpression = target.newInstanceofExpression();
z.add(instanceofExpression);
FunctionInvocation methodInvocation = target.newFunctionInvocation();
z.add(methodInvocation);
Name name = target.newName(new String[]{"a", "b"}); //$NON-NLS-1$ //$NON-NLS-2$
z.add(name);
NullLiteral nullLiteral2 = target.newNullLiteral();
z.add(nullLiteral2);
NumberLiteral numberLiteral = target.newNumberLiteral("1024"); //$NON-NLS-1$
z.add(numberLiteral);
ParenthesizedExpression parenthesizedExpression = target.newParenthesizedExpression();
z.add(parenthesizedExpression);
PostfixExpression postfixExpression = target.newPostfixExpression();
z.add(postfixExpression);
PrefixExpression prefixExpression = target.newPrefixExpression();
z.add(prefixExpression);
StringLiteral stringLiteral = target.newStringLiteral();
z.add(stringLiteral);
SuperFieldAccess superFieldAccess = target.newSuperFieldAccess();
z.add(superFieldAccess);
SuperMethodInvocation superMethodInvocation = target.newSuperMethodInvocation();
z.add(superMethodInvocation);
ThisExpression thisExpression = target.newThisExpression();
z.add(thisExpression);
TypeLiteral typeLiteral = target.newTypeLiteral();
z.add(typeLiteral);
VariableDeclarationFragment variableDeclarationFragment3 = target.newVariableDeclarationFragment();
VariableDeclarationExpression variableDeclarationExpression = target.newVariableDeclarationExpression(variableDeclarationFragment3);
z.add(variableDeclarationExpression);
return cu;
}
/**
* Returns a flat list of sample nodes of each type.
* The sample includes one of each kind, including
* BlockComment and LineComment.
*/
public static List oneOfEachList(AST target) {
List result = new ArrayList(100);
for (int nodeType = 0; nodeType < 100; nodeType++) {
Class nodeClass = null;
try {
nodeClass = ASTNode.nodeClassForType(nodeType);
} catch (RuntimeException e) {
// oops - guess that's not valid
}
if (nodeClass != null) {
result.add(target.createInstance(nodeClass));
}
}
return result;
}
}