/*******************************************************************************
* Copyright (c) 2004, 2006 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.jem.workbench.utility;
import java.text.MessageFormat;
import java.util.HashMap;
import java.util.List;
import org.eclipse.jdt.core.dom.*;
import org.eclipse.jem.internal.instantiation.*;
/**
* Create a parse tree from an AST node.
* @since 1.0.0
*/
public class ParseTreeCreationFromAST extends ASTVisitor {
protected final Resolver resolver;
protected PTExpression expression; // Each visit (or endvisit) will put into expression the result of the visit if it produced an expression.
/**
* This is the abstract base class used by ParseTreeCreationFromAST to resolve the types to the appropriate
* types (e.g. "String" to "java.lang.String").
*
* @see org.eclipse.jem.workbench.utility.ParseTreeCreationFromAST
* @since 1.0.0
*/
public static abstract class Resolver {
/**
* Resolve the Name. It can return either a PTName if it is just a classname,
* or a PTFieldAccess if it resolves to a PTFieldAccess. The PTFieldAccess should
* be complete. e.g we have class like:
* <code>
* package xyz;
* public class AClass {
* public java.awt.Rectangle rect;
* }
* </code>
* Then a Name like <code>AClass.rect.x</code> should resolve to:
*
* PTFieldAccess:
* receiver:
* PTFieldAccess
* receiver: xyz.AClass
* field: "rect"
* field: "x"
*
* Actually it can return any valid expression that has a value (i.e. it cannot be a method invocation with a <code>void</code> return type).
*
* @param name
* @return Either a fully-qualified name (as a PTName) or a PTFieldAccess, any other type of expression.
*
* @since 1.0.0
*/
public abstract PTExpression resolveName(Name name) throws InvalidExpressionException;
/**
* Resolve the type. If it is an array type return it in format "type[][]".
*
* @param type
* @return The type name, including brackets if array type.
*
* @since 1.0.0
*/
public abstract String resolveType(Type type) throws InvalidExpressionException;
/**
* This is for resolving "this" literal. It should either return a PTThisLiteral, if it
* can't do resolve, or some PTExpression that can resolve to "this" for evaluation.
*
* @return If resolvable, a PTExpression, else a PTThisLiteral if not resolvable.
* @throws InvalidExpressionException
*
* @since 1.0.0
*/
public abstract PTExpression resolveThis() throws InvalidExpressionException;
/**
* Resolve the type specified as a Name. It may be a simple name or it may be
* a qualified name. This is used when we have Name that we know must be a
* type. This is so that there is no confusion with it possibly being a field or variable
* that has the same case and spelling as a type name.
* @param name
* @return the type name.
* @throws InvalidExpressionException
*
* @since 1.0.0
*/
public abstract String resolveType(Name name) throws InvalidExpressionException;
/**
* This is used by the resolver if it can't resolve for some reason. This will throw
* an invalid expression exception which will be handled by the ParseTreeCreationFromAST.
*
* @param msg Message to be put into the exception.
* @throws InvalidExpressionException
*
* @since 1.0.0
*/
protected final void throwInvalidExpressionException(String msg) throws InvalidExpressionException {
throw new InvalidExpressionException(msg);
}
}
/*
* When an invalid expression has been found this exception should be thrown. It will
* be caught at the top and converted into an InvalidExpression and the rest of the parse tree will be
* thrown away.
*
* The message will be a message as to why it is invalid.
*
* @since 1.0.0
*/
protected static class InvalidExpressionException extends IllegalArgumentException {
/**
* Comment for <code>serialVersionUID</code>
*
* @since 1.1.0
*/
private static final long serialVersionUID = 2429845631915206678L;
/**
* @param s The message to be used in the final invalid expression.
*
* @since 1.0.0
*/
public InvalidExpressionException(String s) {
super(s);
}
}
/**
* Construct with the given resolver.
*
* @param resolver
*
* @since 1.0.0
*/
public ParseTreeCreationFromAST(Resolver resolver) {
this.resolver = resolver;
}
/**
* Process the AST Expression and return a PTExpression. If any part was invalid, then
* only an PTInvalidExpression will be returned.
*
* @param astExpression
* @return The PTExpression.
*
* @since 1.0.0
*/
public final PTExpression createExpression(Expression astExpression) {
try {
return perform(astExpression);
} catch (InvalidExpressionException e) {
// Create a msg that is formed of the exception message and the full init string.
String msg = MessageFormat.format(WorkbenchUtilityMessages.ParseTreeCreationFromAST_0, new Object[] {e.getLocalizedMessage(), astExpression.toString()});
PTInvalidExpression exp = InstantiationFactory.eINSTANCE.createPTInvalidExpression();
exp.setMessage(msg);
return exp;
}
}
/*
* Visit the AST expression and get the ParseTree Expression.
* This is used by the individual visits when parsing a tree.
* It passes to the top method (createExpression), which can
* handle the InvalidExpressionException.
*
* If any visit doesn't return an expression, then an invalid
* expression exception will be thrown to indicate this. If the
* incoming expression is <code>null</code>, then return of <code>null</code> is ok because
* this would be for an optional expression which didn't exist.
*
* @return The new ParseTree Expression or <code>null</code> if incoming expression was null.
*
* @see createExpression(org.eclipse.jdt.core.dom.Expression)
* @exception InvalidExpressionException
* @since 1.0.0
*/
protected final PTExpression perform(Expression astExpression) {
if (astExpression != null) {
expression = null;
astExpression.accept(this);
if (expression == null)
throw new InvalidExpressionException(MessageFormat.format(WorkbenchUtilityMessages.ParseTreeCreationFromAST_ExpressionTooComplicated_EXC_, new Object[] {astExpression.toString()}));
return expression;
} else
return null; // This is ok. It means an optional expression was being processed and the expression didn't exist.
}
/* (non-Javadoc)
* @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ArrayAccess)
*/
public boolean visit(ArrayAccess node) {
PTArrayAccess aa = InstantiationFactory.eINSTANCE.createPTArrayAccess();
List indexes = aa.getIndexes();
Expression arrayExp = node;
while (arrayExp.getNodeType() == ASTNode.ARRAY_ACCESS) {
// Visit the index to get the index expression.
ArrayAccess array = (ArrayAccess) arrayExp;
indexes.add(0, perform(array.getIndex())); // We're trying to create the final expression from inside out, the indexes are created in reverse order.
arrayExp = array.getArray();
}
aa.setArray(perform(arrayExp)); // Final arrayExp is the true expression.
expression = aa; // Set the return expression for this visit.
return false;
}
/* (non-Javadoc)
* @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ArrayCreation)
*/
public boolean visit(ArrayCreation node) {
PTArrayCreation ac = InstantiationFactory.eINSTANCE.createPTArrayCreation();
ac.setType(resolver.resolveType(node.getType()));
List acDims = ac.getDimensions();
List nDims = node.dimensions();
int nsize = nDims.size();
for (int i = 0; i < nsize; i++) {
acDims.add(perform((Expression) nDims.get(i)));
}
ac.setInitializer((PTArrayInitializer) perform(node.getInitializer()));
expression = ac;
return false;
}
/* (non-Javadoc)
* @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ArrayInitializer)
*/
public boolean visit(ArrayInitializer node) {
PTArrayInitializer ai = InstantiationFactory.eINSTANCE.createPTArrayInitializer();
List exps = node.expressions();
List aiexps = ai.getExpressions();
int nexp = exps.size();
for (int i = 0; i < nexp; i++) {
aiexps.add(perform((Expression) exps.get(i)));
}
expression = ai;
return false;
}
/* (non-Javadoc)
* @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.Assignment)
*/
public boolean visit(Assignment node) {
return false; // We can't handle assignment.
}
/* (non-Javadoc)
* @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.BooleanLiteral)
*/
public boolean visit(BooleanLiteral node) {
PTBooleanLiteral bl = InstantiationFactory.eINSTANCE.createPTBooleanLiteral();
bl.setBooleanValue(node.booleanValue());
expression = bl;
return false;
}
/* (non-Javadoc)
* @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.CastExpression)
*/
public boolean visit(CastExpression node) {
PTCastExpression ct = InstantiationFactory.eINSTANCE.createPTCastExpression();
ct.setType(resolver.resolveType(node.getType()));
ct.setExpression(perform(node.getExpression()));
expression = ct;
return false;
}
/* (non-Javadoc)
* @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.CharacterLiteral)
*/
public boolean visit(CharacterLiteral node) {
PTCharacterLiteral cl = InstantiationFactory.eINSTANCE.createPTCharacterLiteral();
cl.setEscapedValue(node.getEscapedValue());
cl.setCharValue(node.charValue());
expression = cl;
return false;
}
/* (non-Javadoc)
* @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ClassInstanceCreation)
*/
public boolean visit(ClassInstanceCreation node) {
if (node.getAnonymousClassDeclaration() != null) {
PTAnonymousClassDeclaration adecl = InstantiationFactory.eINSTANCE.createPTAnonymousClassDeclaration();
adecl.setDeclaration(node.toString());
expression = adecl;
} else {
PTClassInstanceCreation cic = InstantiationFactory.eINSTANCE.createPTClassInstanceCreation();
// If ast level = 2, then you must use getName, but the name needs to be turned into a type
// so that it can be resolved. If ast level > 2, then it will return a type to be resolved.
// Note: can't just use resolve name on the name because if a field and a class were spelled
// the same then the codegen resolver would return an instance ref to the field instead.
String type = node.getAST().apiLevel() == AST.JLS2 ? resolver.resolveType(node.getName()) : resolver.resolveType(node.getType());
if (type == null) {
type = node.getAST().apiLevel() == AST.JLS2 ? node.getName().getFullyQualifiedName() : node.getType().toString();
}
cic.setType(type);
List args = cic.getArguments();
List nargs = node.arguments();
int nsize = nargs.size();
for (int i = 0; i < nsize; i++) {
args.add(perform((Expression) nargs.get(i)));
}
expression = cic;
}
return false;
}
/*
* (non-Javadoc)
*
* @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ConditionalExpression)
*/
public boolean visit(ConditionalExpression node) {
PTConditionalExpression ce = InstantiationFactory.eINSTANCE.createPTConditionalExpression();
ce.setCondition(perform(node.getExpression()));
ce.setTrue(perform(node.getThenExpression()));
ce.setFalse(perform(node.getElseExpression()));
expression = ce;
return false;
}
/* (non-Javadoc)
* @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.FieldAccess)
*/
public boolean visit(FieldAccess node) {
expression = createFieldAccess(node.getName().getIdentifier(), perform(node.getExpression()));
return false;
}
protected PTExpression createFieldAccess(String name, PTExpression receiver) {
PTFieldAccess fa = InstantiationFactory.eINSTANCE.createPTFieldAccess();
fa.setReceiver(receiver);
fa.setField(name);
return fa;
}
private static HashMap infixOperToParseOper;
private final PTInfixOperator getParseInfix(InfixExpression.Operator operator) {
if (prefixOperToParseOper == null) {
infixOperToParseOper = new HashMap(5);
infixOperToParseOper.put(InfixExpression.Operator.AND, PTInfixOperator.AND_LITERAL);
infixOperToParseOper.put(InfixExpression.Operator.CONDITIONAL_AND, PTInfixOperator.CONDITIONAL_AND_LITERAL);
infixOperToParseOper.put(InfixExpression.Operator.CONDITIONAL_OR, PTInfixOperator.CONDITIONAL_OR_LITERAL);
infixOperToParseOper.put(InfixExpression.Operator.DIVIDE, PTInfixOperator.DIVIDE_LITERAL);
infixOperToParseOper.put(InfixExpression.Operator.EQUALS, PTInfixOperator.EQUALS_LITERAL);
infixOperToParseOper.put(InfixExpression.Operator.GREATER_EQUALS, PTInfixOperator.GREATER_EQUALS_LITERAL);
infixOperToParseOper.put(InfixExpression.Operator.GREATER, PTInfixOperator.GREATER_LITERAL);
infixOperToParseOper.put(InfixExpression.Operator.LEFT_SHIFT, PTInfixOperator.LEFT_SHIFT_LITERAL);
infixOperToParseOper.put(InfixExpression.Operator.LESS_EQUALS, PTInfixOperator.LESS_EQUALS_LITERAL);
infixOperToParseOper.put(InfixExpression.Operator.LESS, PTInfixOperator.LESS_LITERAL);
infixOperToParseOper.put(InfixExpression.Operator.MINUS, PTInfixOperator.MINUS_LITERAL);
infixOperToParseOper.put(InfixExpression.Operator.NOT_EQUALS, PTInfixOperator.NOT_EQUALS_LITERAL);
infixOperToParseOper.put(InfixExpression.Operator.OR, PTInfixOperator.OR_LITERAL);
infixOperToParseOper.put(InfixExpression.Operator.PLUS, PTInfixOperator.PLUS_LITERAL);
infixOperToParseOper.put(InfixExpression.Operator.REMAINDER, PTInfixOperator.REMAINDER_LITERAL);
infixOperToParseOper.put(InfixExpression.Operator.RIGHT_SHIFT_SIGNED, PTInfixOperator.RIGHT_SHIFT_SIGNED_LITERAL);
infixOperToParseOper.put(InfixExpression.Operator.RIGHT_SHIFT_UNSIGNED, PTInfixOperator.RIGHT_SHIFT_UNSIGNED_LITERAL);
infixOperToParseOper.put(InfixExpression.Operator.TIMES, PTInfixOperator.TIMES_LITERAL);
infixOperToParseOper.put(InfixExpression.Operator.XOR, PTInfixOperator.XOR_LITERAL);
}
return (PTInfixOperator) infixOperToParseOper.get(operator);
}
/* (non-Javadoc)
* @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.InfixExpression)
*/
public boolean visit(InfixExpression node) {
PTInfixExpression inf = InstantiationFactory.eINSTANCE.createPTInfixExpression();
inf.setLeftOperand(perform(node.getLeftOperand()));
PTInfixOperator inoper = getParseInfix(node.getOperator());
if (inoper == null) {
// It is not one we can handle.
throw new InvalidExpressionException(
MessageFormat.format(WorkbenchUtilityMessages.ParseTreeCreationFromAST_OperatorTooComplicatedToHandle_EXC_, new Object[] { node.getOperator().toString() }));
}
inf.setOperator(inoper);
inf.setRightOperand(perform(node.getRightOperand()));
List eops = inf.getExtendedOperands();
List neops = node.extendedOperands();
int nsize = neops.size();
for (int i = 0; i < nsize; i++) {
eops.add(perform((Expression) neops.get(i)));
}
expression = inf;
return false;
}
/* (non-Javadoc)
* @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.InstanceofExpression)
*/
public boolean visit(InstanceofExpression node) {
PTInstanceof inof = InstantiationFactory.eINSTANCE.createPTInstanceof();
inof.setOperand(perform(node.getLeftOperand()));
inof.setType(resolver.resolveType(node.getRightOperand()));
expression = inof;
return false;
}
/* (non-Javadoc)
* @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.PostfixExpression)
*/
public boolean visit(PostfixExpression node) {
return false; // We can't handle post fix.
}
/* (non-Javadoc)
* @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.MethodInvocation)
*/
public boolean visit(MethodInvocation node) {
expression = createMethodInvocation(node.getName().getIdentifier(), perform(node.getExpression()), node.arguments());
return false;
}
/**
* Create a method invocation using the giving receiver, name, args.
* @param node
* @return
*
* @since 1.2.0
*/
protected PTMethodInvocation createMethodInvocation(String name, PTExpression receiver, List argExpressions) {
PTMethodInvocation mi = InstantiationFactory.eINSTANCE.createPTMethodInvocation();
mi.setReceiver(receiver);
mi.setName(name);
List args = mi.getArguments();
int nsize = argExpressions.size();
for (int i = 0; i < nsize; i++) {
args.add(perform((Expression) argExpressions.get(i)));
}
return mi;
}
/* (non-Javadoc)
* @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.NullLiteral)
*/
public boolean visit(NullLiteral node) {
expression = InstantiationFactory.eINSTANCE.createPTNullLiteral();
return false;
}
/* (non-Javadoc)
* @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.NumberLiteral)
*/
public boolean visit(NumberLiteral node) {
PTNumberLiteral nl = InstantiationFactory.eINSTANCE.createPTNumberLiteral();
nl.setToken(node.getToken());
expression = nl;
return false;
}
/* (non-Javadoc)
* @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ParenthesizedExpression)
*/
public boolean visit(ParenthesizedExpression node) {
PTParenthesizedExpression pe = InstantiationFactory.eINSTANCE.createPTParenthesizedExpression();
pe.setExpression(perform(node.getExpression()));
expression = pe;
return false;
}
private static HashMap prefixOperToParseOper;
private final PTPrefixOperator getParsePrefix(PrefixExpression.Operator operator) {
if (prefixOperToParseOper == null) {
prefixOperToParseOper = new HashMap(5);
prefixOperToParseOper.put(PrefixExpression.Operator.COMPLEMENT, PTPrefixOperator.COMPLEMENT_LITERAL);
prefixOperToParseOper.put(PrefixExpression.Operator.MINUS, PTPrefixOperator.MINUS_LITERAL);
prefixOperToParseOper.put(PrefixExpression.Operator.NOT, PTPrefixOperator.NOT_LITERAL);
prefixOperToParseOper.put(PrefixExpression.Operator.PLUS, PTPrefixOperator.PLUS_LITERAL);
}
return (PTPrefixOperator) prefixOperToParseOper.get(operator);
}
/* (non-Javadoc)
* @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.PrefixExpression)
*/
public boolean visit(PrefixExpression node) {
if (node.getOperand().getNodeType() == ASTNode.NUMBER_LITERAL) {
// For number literals we see if it is a "+" or "-" prefix, and if it is, we simply
// create a PTNumberLiteral with the operator already in it. It is a simplification.
// Any other operator we've left alone since those won't be decoded simply by the
// Number decoder.
// If not a number literal, then leave alone since needs to be handled as a prefix
// operation.
PrefixExpression.Operator operator = node.getOperator();
if (operator == PrefixExpression.Operator.PLUS || operator == PrefixExpression.Operator.MINUS) {
PTNumberLiteral nm = InstantiationFactory.eINSTANCE.createPTNumberLiteral();
nm.setToken(operator.toString() + ((NumberLiteral) node.getOperand()).getToken());
expression = nm;
return false;
}
}
PTPrefixExpression pe = InstantiationFactory.eINSTANCE.createPTPrefixExpression();
PTPrefixOperator ptoper = getParsePrefix(node.getOperator());
if (ptoper == null) {
// It is not one we can handle.
throw new InvalidExpressionException(
MessageFormat.format(WorkbenchUtilityMessages.ParseTreeCreationFromAST_OperatorTooComplicatedToHandle_EXC_, new Object[] { node.getOperator().toString() }));
}
pe.setOperator(ptoper);
pe.setExpression(perform(node.getOperand()));
expression = pe;
return false;
}
/* (non-Javadoc)
* @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.QualifiedName)
*/
public boolean visit(QualifiedName node) {
expression = resolver.resolveName(node);
return false;
}
/* (non-Javadoc)
* @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.SimpleName)
*/
public boolean visit(SimpleName node) {
expression = resolver.resolveName(node);
return false;
}
/* (non-Javadoc)
* @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.StringLiteral)
*/
public boolean visit(StringLiteral node) {
PTStringLiteral sl = InstantiationFactory.eINSTANCE.createPTStringLiteral();
sl.setEscapedValue(node.getEscapedValue());
sl.setLiteralValue(node.getLiteralValue());
expression = sl;
return false;
}
/* (non-Javadoc)
* @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.SuperFieldAccess)
*/
public boolean visit(SuperFieldAccess node) {
expression = createFieldAccess(node.getName().getIdentifier(), resolver.resolveThis());
return false;
}
/* (non-Javadoc)
* @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.SuperMethodInvocation)
*/
public boolean visit(SuperMethodInvocation node) {
expression = createMethodInvocation(node.getName().getIdentifier(), resolver.resolveThis(), node.arguments());
return false;
}
/* (non-Javadoc)
* @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ThisExpression)
*/
public boolean visit(ThisExpression node) {
expression = resolver.resolveThis();
return false;
}
/* (non-Javadoc)
* @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.TypeLiteral)
*/
public boolean visit(TypeLiteral node) {
PTTypeLiteral ptl = InstantiationFactory.eINSTANCE.createPTTypeLiteral();
ptl.setType(resolver.resolveType(node.getType()));
expression = ptl;
return false;
}
}