/*******************************************************************************
* Copyright (c) 2000, 2015 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
* Jesper Steen Moller - bug 341232
*******************************************************************************/
package org.eclipse.jdt.internal.debug.eval.ast.engine;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Stack;
import org.eclipse.jdt.core.Flags;
import org.eclipse.jdt.core.ISourceRange;
import org.eclipse.jdt.core.IType;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.core.Signature;
import org.eclipse.jdt.core.SourceRange;
import org.eclipse.jdt.core.dom.ASTNode;
import org.eclipse.jdt.core.dom.ASTVisitor;
import org.eclipse.jdt.core.dom.AbstractTypeDeclaration;
import org.eclipse.jdt.core.dom.AnnotationTypeDeclaration;
import org.eclipse.jdt.core.dom.AnnotationTypeMemberDeclaration;
import org.eclipse.jdt.core.dom.AnonymousClassDeclaration;
import org.eclipse.jdt.core.dom.ArrayAccess;
import org.eclipse.jdt.core.dom.ArrayCreation;
import org.eclipse.jdt.core.dom.ArrayInitializer;
import org.eclipse.jdt.core.dom.ArrayType;
import org.eclipse.jdt.core.dom.AssertStatement;
import org.eclipse.jdt.core.dom.Assignment;
import org.eclipse.jdt.core.dom.Block;
import org.eclipse.jdt.core.dom.BlockComment;
import org.eclipse.jdt.core.dom.BodyDeclaration;
import org.eclipse.jdt.core.dom.BooleanLiteral;
import org.eclipse.jdt.core.dom.BreakStatement;
import org.eclipse.jdt.core.dom.CastExpression;
import org.eclipse.jdt.core.dom.CatchClause;
import org.eclipse.jdt.core.dom.CharacterLiteral;
import org.eclipse.jdt.core.dom.ClassInstanceCreation;
import org.eclipse.jdt.core.dom.CompilationUnit;
import org.eclipse.jdt.core.dom.ConditionalExpression;
import org.eclipse.jdt.core.dom.ConstructorInvocation;
import org.eclipse.jdt.core.dom.ContinueStatement;
import org.eclipse.jdt.core.dom.DoStatement;
import org.eclipse.jdt.core.dom.EmptyStatement;
import org.eclipse.jdt.core.dom.EnhancedForStatement;
import org.eclipse.jdt.core.dom.EnumConstantDeclaration;
import org.eclipse.jdt.core.dom.EnumDeclaration;
import org.eclipse.jdt.core.dom.ExpressionStatement;
import org.eclipse.jdt.core.dom.FieldAccess;
import org.eclipse.jdt.core.dom.FieldDeclaration;
import org.eclipse.jdt.core.dom.ForStatement;
import org.eclipse.jdt.core.dom.IfStatement;
import org.eclipse.jdt.core.dom.ImportDeclaration;
import org.eclipse.jdt.core.dom.InfixExpression;
import org.eclipse.jdt.core.dom.Initializer;
import org.eclipse.jdt.core.dom.InstanceofExpression;
import org.eclipse.jdt.core.dom.Javadoc;
import org.eclipse.jdt.core.dom.LabeledStatement;
import org.eclipse.jdt.core.dom.LineComment;
import org.eclipse.jdt.core.dom.MarkerAnnotation;
import org.eclipse.jdt.core.dom.MemberRef;
import org.eclipse.jdt.core.dom.MemberValuePair;
import org.eclipse.jdt.core.dom.MethodDeclaration;
import org.eclipse.jdt.core.dom.MethodInvocation;
import org.eclipse.jdt.core.dom.MethodRef;
import org.eclipse.jdt.core.dom.MethodRefParameter;
import org.eclipse.jdt.core.dom.Modifier;
import org.eclipse.jdt.core.dom.Name;
import org.eclipse.jdt.core.dom.NormalAnnotation;
import org.eclipse.jdt.core.dom.NullLiteral;
import org.eclipse.jdt.core.dom.NumberLiteral;
import org.eclipse.jdt.core.dom.PackageDeclaration;
import org.eclipse.jdt.core.dom.ParameterizedType;
import org.eclipse.jdt.core.dom.ParenthesizedExpression;
import org.eclipse.jdt.core.dom.PostfixExpression;
import org.eclipse.jdt.core.dom.PrefixExpression;
import org.eclipse.jdt.core.dom.PrimitiveType;
import org.eclipse.jdt.core.dom.QualifiedName;
import org.eclipse.jdt.core.dom.QualifiedType;
import org.eclipse.jdt.core.dom.ReturnStatement;
import org.eclipse.jdt.core.dom.SimpleName;
import org.eclipse.jdt.core.dom.SimpleType;
import org.eclipse.jdt.core.dom.SingleMemberAnnotation;
import org.eclipse.jdt.core.dom.SingleVariableDeclaration;
import org.eclipse.jdt.core.dom.StringLiteral;
import org.eclipse.jdt.core.dom.SuperConstructorInvocation;
import org.eclipse.jdt.core.dom.SuperFieldAccess;
import org.eclipse.jdt.core.dom.SuperMethodInvocation;
import org.eclipse.jdt.core.dom.SwitchCase;
import org.eclipse.jdt.core.dom.SwitchStatement;
import org.eclipse.jdt.core.dom.SynchronizedStatement;
import org.eclipse.jdt.core.dom.TagElement;
import org.eclipse.jdt.core.dom.TextElement;
import org.eclipse.jdt.core.dom.ThisExpression;
import org.eclipse.jdt.core.dom.ThrowStatement;
import org.eclipse.jdt.core.dom.TryStatement;
import org.eclipse.jdt.core.dom.Type;
import org.eclipse.jdt.core.dom.TypeDeclaration;
import org.eclipse.jdt.core.dom.TypeDeclarationStatement;
import org.eclipse.jdt.core.dom.TypeLiteral;
import org.eclipse.jdt.core.dom.TypeParameter;
import org.eclipse.jdt.core.dom.UnionType;
import org.eclipse.jdt.core.dom.VariableDeclarationExpression;
import org.eclipse.jdt.core.dom.VariableDeclarationFragment;
import org.eclipse.jdt.core.dom.VariableDeclarationStatement;
import org.eclipse.jdt.core.dom.WhileStatement;
import org.eclipse.jdt.core.dom.WildcardType;
import org.eclipse.jdt.internal.debug.core.JDIDebugPlugin;
public class SourceBasedSourceGenerator extends ASTVisitor {
private static final String RUN_METHOD_NAME = "___run"; //$NON-NLS-1$
private static final String EVAL_METHOD_NAME = "___eval"; //$NON-NLS-1$
private static final String EVAL_FIELD_NAME = "___field"; //$NON-NLS-1$
private String[] fLocalVariableTypeNames;
private String[] fLocalVariableNames;
private String fCodeSnippet;
private boolean fRightTypeFound;
private boolean fCreateInAStaticMethod;
private boolean fEvaluateNextEndTypeDeclaration;
private String fError;
private IType fType;
private int fLine;
private StringBuffer fSource;
private String fLastTypeName;
private String fCompilationUnitName;
private int fSnippetStartPosition;
private int fRunMethodStartOffset;
private int fRunMethodLength;
/**
* Level of source code to generate (major, minor). For example 1 and 4
* indicates 1.4.
*/
private int fSourceMajorLevel;
private int fSourceMinorLevel;
private Stack<Map<String, String>> fTypeParameterStack = new Stack<>();
private Map<String, String> fMatchingTypeParameters = null;
private CompilationUnit fCompilationUnit;
{
fTypeParameterStack.push(Collections.<String,String>emptyMap());
}
/**
* if the <code>createInAnInstanceMethod</code> flag is set, the method
* created which contains the code snippet is an no-static method, even if
* <code>position</code> is in a static method.
*
* @param type
* the root {@link IType}
* @param sourcePosition
* the reference position in the type's source
* @param createInAStaticMethod
* if the source should be generated
* @param localTypesNames
* the array of local type names
* @param localVariables
* the listing of local variable names
* @param codeSnippet
* the code snippet
* @param sourceLevel
* the desired source level
*/
public SourceBasedSourceGenerator(IType type,
int line, boolean createInAStaticMethod, String[] localTypesNames,
String[] localVariables, String codeSnippet, String sourceLevel) {
fRightTypeFound = false;
fType = type;
fLine = line;
fLocalVariableTypeNames = localTypesNames;
fLocalVariableNames = localVariables;
fCodeSnippet = codeSnippet;
fCreateInAStaticMethod = createInAStaticMethod;
int index = sourceLevel.indexOf('.');
String num = sourceLevel.substring(0, index);
fSourceMajorLevel = Integer.valueOf(num).intValue();
num = sourceLevel.substring(index + 1);
fSourceMinorLevel = Integer.valueOf(num).intValue();
}
/**
* Returns the generated source or <code>null</code> if no source can be
* generated.
*
* @return returns the backing source from the generator
*/
public String getSource() {
if (fSource == null) {
return null;
}
return fSource.toString();
}
public String getCompilationUnitName() {
return fCompilationUnitName;
}
public int getSnippetStart() {
return fSnippetStartPosition;
}
public int getRunMethodStart() {
return fSnippetStartPosition - fRunMethodStartOffset;
}
public int getRunMethodLength() {
return fRunMethodLength;
}
private boolean rightTypeFound() {
return fRightTypeFound;
}
private void setRightTypeFound(boolean value) {
fRightTypeFound = value;
}
public boolean hasError() {
return fError != null;
}
public void setError(String errorDesc) {
fError = errorDesc;
}
public String getError() {
return fError;
}
private StringBuffer buildRunMethod(List<BodyDeclaration> bodyDeclarations) {
StringBuffer buffer = new StringBuffer();
if (fCreateInAStaticMethod) {
buffer.append("static "); //$NON-NLS-1$
}
adddTypeParameters(buffer);
buffer.append("void "); //$NON-NLS-1$
buffer.append(getUniqueMethodName(RUN_METHOD_NAME, bodyDeclarations));
buffer.append('(');
for (int i = 0, length = fLocalVariableNames.length; i < length; i++) {
buffer.append(getDotName(fLocalVariableTypeNames[i]));
buffer.append(' ');
buffer.append(fLocalVariableNames[i]);
if (i + 1 < length)
buffer.append(", "); //$NON-NLS-1$
}
buffer.append(") throws Throwable {"); //$NON-NLS-1$
buffer.append('\n');
fSnippetStartPosition = buffer.length() - 2;
fRunMethodStartOffset = fSnippetStartPosition;
String codeSnippet = new String(fCodeSnippet).trim();
buffer.append(codeSnippet);
buffer.append('\n');
buffer.append('}').append('\n');
fRunMethodLength = buffer.length();
return buffer;
}
private String getDotName(String typeName) {
return typeName.replace('$', '.');
}
/**
* Adds generic type parameters as needed to the given buffer
*
* @param buffer
* @since 3.8.0
*/
void adddTypeParameters(StringBuffer buffer) {
if (isSourceLevelGreaterOrEqual(1, 5)) {
Collection<String> activeTypeParameters = (fMatchingTypeParameters != null ? fMatchingTypeParameters : fTypeParameterStack.peek()).values();
if (!activeTypeParameters.isEmpty()) {
Iterator<String> iterator = activeTypeParameters.iterator();
buffer.append(Signature.C_GENERIC_START);
while (iterator.hasNext()) {
String name = iterator.next();
buffer.append(name);
if (iterator.hasNext()) {
buffer.append(", "); //$NON-NLS-1$
}
}
buffer.append(Signature.C_GENERIC_END);
buffer.append(' ');
}
}
}
/**
* Returns if the specified {@link ASTNode} has the 'correct' parent type to
* match the current type name context
*
* @param node
* the {@link ASTNode} to check source ranges for
* @return true if the parent type of the given node matches the current
* type name context, false otherwise
*/
private boolean isRightType(ASTNode node) {
try {
switch(node.getNodeType()) {
case ASTNode.ANNOTATION_TYPE_DECLARATION:
case ASTNode.ENUM_DECLARATION:
case ASTNode.TYPE_DECLARATION: {
AbstractTypeDeclaration decl = (AbstractTypeDeclaration) node;
SimpleName name = decl.getName();
ISourceRange range = new SourceRange(name.getStartPosition(), name.getLength());
return fType.getNameRange().equals(range);
}
case ASTNode.ANONYMOUS_CLASS_DECLARATION: {
return isRightType(node.getParent());
}
case ASTNode.CLASS_INSTANCE_CREATION: {
ClassInstanceCreation decl = (ClassInstanceCreation) node;
Type type = decl.getType();
ISourceRange name = fType.getNameRange();
return name.getOffset() >= type.getStartPosition() &&
name.getOffset()+name.getLength() <= type.getStartPosition()+type.getLength();
}
}
}
catch(JavaModelException jme) {
JDIDebugPlugin.log(jme);
}
return false;
}
private StringBuffer buildTypeBody(StringBuffer buffer, List<BodyDeclaration> list) {
StringBuffer source = new StringBuffer();
source.append('{').append('\n');
if (buffer != null) {
fSnippetStartPosition += source.length();
}
source.append(buildBody(buffer, list));
source.append('}').append('\n');
return source;
}
private StringBuffer buildEnumBody(StringBuffer buffer,
List<EnumConstantDeclaration> constantDeclarations, List<BodyDeclaration> bodyDeclarations) {
StringBuffer source = new StringBuffer();
source.append('{').append('\n');
if (constantDeclarations.isEmpty()) {
source.append(';').append('\n');
} else {
for (Iterator<EnumConstantDeclaration> iter = constantDeclarations.iterator(); iter
.hasNext();) {
source.append(iter.next().getName()
.getIdentifier());
if (iter.hasNext()) {
source.append(',');
} else {
source.append(';');
}
source.append('\n');
}
}
if (buffer != null) {
fSnippetStartPosition += source.length();
}
source.append(buildBody(buffer, bodyDeclarations));
source.append('}').append('\n');
return source;
}
/**
* Builds up the given buffer with the source from each of
* {@link BodyDeclaration}s in the given list
*
* @param buffer
* the buffer to clone and append to
* @param list
* the list of {@link BodyDeclaration}s
* @return the new source buffer
*/
private StringBuffer buildBody(StringBuffer buffer, List<BodyDeclaration> list) {
StringBuffer source = new StringBuffer();
if (buffer != null) {
fSnippetStartPosition += source.length();
source.append(buffer.toString());
}
for (Iterator<BodyDeclaration> iterator = list.iterator(); iterator.hasNext();) {
BodyDeclaration bodyDeclaration = iterator.next();
if (bodyDeclaration instanceof FieldDeclaration) {
source.append(buildFieldDeclaration((FieldDeclaration) bodyDeclaration));
} else if (bodyDeclaration instanceof MethodDeclaration) {
source.append(buildMethodDeclaration((MethodDeclaration) bodyDeclaration));
} else if (bodyDeclaration instanceof TypeDeclaration) {
TypeDeclaration typeDeclaration = (TypeDeclaration) bodyDeclaration;
if (!typeDeclaration.getName().getIdentifier()
.equals(fLastTypeName)) {
source.append(buildTypeDeclaration(null, typeDeclaration));
}
} else if (bodyDeclaration instanceof EnumDeclaration) {
EnumDeclaration enumDeclaration = (EnumDeclaration) bodyDeclaration;
if (!enumDeclaration.getName().getIdentifier()
.equals(fLastTypeName)) {
source.append(buildEnumDeclaration(null, enumDeclaration));
}
}
}
return source;
}
private StringBuffer buildFieldDeclaration(FieldDeclaration fieldDeclaration) {
StringBuffer source = new StringBuffer();
source.append(Flags.toString(fieldDeclaration.getModifiers()));
source.append(' ');
source.append(getDotName(getTypeName(fieldDeclaration.getType())));
source.append(' ');
boolean first = true;
for (Iterator<VariableDeclarationFragment> iterator = fieldDeclaration.fragments().iterator(); iterator
.hasNext();) {
VariableDeclarationFragment variableDeclarationFragment = iterator
.next();
if (first) {
first = false;
} else {
source.append(',');
}
source.append(variableDeclarationFragment.getName().getIdentifier());
for (int i = 0, dim = variableDeclarationFragment
.getExtraDimensions(); i < dim; i++) {
source.append('[').append(']');
}
}
source.append(';').append('\n');
return source;
}
private StringBuffer buildMethodDeclaration(
MethodDeclaration methodDeclaration) {
StringBuffer source = new StringBuffer();
int modifiers = methodDeclaration.getModifiers();
source.append(Flags.toString(modifiers));
source.append(' ');
appendTypeParameters(source, methodDeclaration.typeParameters());
boolean isConstructor = methodDeclaration.isConstructor();
if (!isConstructor) {
source.append(getDotName(getTypeName(methodDeclaration
.getReturnType2())));
source.append(' ');
}
source.append(methodDeclaration.getName().getIdentifier());
source.append(' ').append('(');
boolean first = true;
for (Iterator<SingleVariableDeclaration> iterator = methodDeclaration.parameters().iterator(); iterator
.hasNext();) {
SingleVariableDeclaration singleVariableDeclaration = iterator
.next();
if (first) {
first = false;
} else {
source.append(',');
}
source.append(getDotName(getTypeName(singleVariableDeclaration
.getType())));
if (singleVariableDeclaration.isVarargs()) {
source.append("..."); //$NON-NLS-1$
}
source.append(' ');
source.append(singleVariableDeclaration.getName().getIdentifier());
appendExtraDimensions(source,
singleVariableDeclaration.getExtraDimensions());
}
source.append(')');
appendExtraDimensions(source, methodDeclaration.getExtraDimensions());
first = true;
for (Iterator<Name> iterator = methodDeclaration.thrownExceptions()
.iterator(); iterator.hasNext();) {
Name name = iterator.next();
if (first) {
first = false;
source.append(" throws "); //$NON-NLS-1$
} else {
source.append(',');
}
source.append(getQualifiedIdentifier(name));
}
if (Flags.isAbstract(modifiers) || Flags.isNative(modifiers)) {
// No body for abstract and native methods
source.append(";\n"); //$NON-NLS-1$
} else {
source.append('{').append('\n');
if (!isConstructor) {
source.append(getReturnExpression(methodDeclaration
.getReturnType2()));
}
source.append('}').append('\n');
}
return source;
}
private void appendExtraDimensions(StringBuffer source, int extraDimension) {
if (extraDimension > 0) {
source.append(' ');
for (int i = 0; i < extraDimension; i++) {
source.append("[]"); //$NON-NLS-1$
}
}
}
private StringBuffer buildEnumDeclaration(StringBuffer buffer,
EnumDeclaration enumDeclaration) {
StringBuffer source = new StringBuffer();
source.append(Flags.toString(enumDeclaration.getModifiers()));
source.append(" enum "); //$NON-NLS-1$
source.append(enumDeclaration.getName().getIdentifier());
Iterator<Type> iterator = enumDeclaration.superInterfaceTypes().iterator();
if (iterator.hasNext()) {
source.append(" implements "); //$NON-NLS-1$
source.append(getTypeName(iterator.next()));
while (iterator.hasNext()) {
source.append(',');
source.append(getTypeName(iterator.next()));
}
}
if (buffer != null) {
fSnippetStartPosition += source.length();
}
source.append(buildEnumBody(buffer, enumDeclaration.enumConstants(),
enumDeclaration.bodyDeclarations()));
return source;
}
private StringBuffer buildTypeDeclaration(StringBuffer buffer,
TypeDeclaration typeDeclaration) {
StringBuffer source = new StringBuffer();
source.append(Flags.toString(typeDeclaration.getModifiers()));
if (typeDeclaration.isInterface()) {
source.append(" interface "); //$NON-NLS-1$
} else {
source.append(" class "); //$NON-NLS-1$
}
source.append(typeDeclaration.getName().getIdentifier());
List<TypeParameter> typeParameters = typeDeclaration.typeParameters();
if (!typeParameters.isEmpty() && isSourceLevelGreaterOrEqual(1, 5)) {
source.append('<');
Iterator<TypeParameter> iter = typeParameters.iterator();
TypeParameter typeParameter = iter.next();
source.append(typeParameter.getName().getIdentifier());
List<Type> typeBounds = typeParameter.typeBounds();
if (!typeBounds.isEmpty()) {
source.append(" extends "); //$NON-NLS-1$
Iterator<Type> iter2 = typeBounds.iterator();
source.append(getTypeName(iter2.next()));
while (iter2.hasNext()) {
source.append('&');
source.append(getTypeName(iter2.next()));
}
}
while (iter.hasNext()) {
source.append(',');
typeParameter = iter.next();
source.append(typeParameter.getName().getIdentifier());
typeBounds = typeParameter.typeBounds();
if (!typeBounds.isEmpty()) {
source.append(" extends "); //$NON-NLS-1$
Iterator<Type> iter2 = typeBounds.iterator();
source.append(getTypeName(iter2.next()));
while (iter2.hasNext()) {
source.append('&');
source.append(getTypeName(iter2.next()));
}
}
}
source.append('>');
}
Type superClass = typeDeclaration.getSuperclassType();
if (superClass != null) {
source.append(" extends "); //$NON-NLS-1$
source.append(getTypeName(superClass));
}
Iterator<Type> iter = typeDeclaration.superInterfaceTypes().iterator();
if (iter.hasNext()) {
if (typeDeclaration.isInterface()) {
source.append(" extends "); //$NON-NLS-1$
} else {
source.append(" implements "); //$NON-NLS-1$
}
source.append(getTypeName(iter.next()));
while (iter.hasNext()) {
source.append(',');
source.append(getTypeName(iter.next()));
}
}
if (buffer != null) {
fSnippetStartPosition += source.length();
}
source.append(buildTypeBody(buffer, typeDeclaration.bodyDeclarations()));
return source;
}
private StringBuffer buildCompilationUnit(StringBuffer buffer,
CompilationUnit compilationUnit) {
StringBuffer source = new StringBuffer();
PackageDeclaration packageDeclaration = compilationUnit.getPackage();
if (packageDeclaration != null) {
source.append("package "); //$NON-NLS-1$
source.append(getQualifiedIdentifier(packageDeclaration.getName()));
source.append(";\n"); //$NON-NLS-1$
}
for (Iterator<ImportDeclaration> iterator = compilationUnit.imports().iterator(); iterator
.hasNext();) {
ImportDeclaration importDeclaration = iterator
.next();
source.append("import "); //$NON-NLS-1$
if (importDeclaration.isStatic()) {
source.append("static "); //$NON-NLS-1$
}
source.append(getQualifiedIdentifier(importDeclaration.getName()));
if (importDeclaration.isOnDemand()) {
source.append(".*"); //$NON-NLS-1$
}
source.append(";\n"); //$NON-NLS-1$
}
fSnippetStartPosition += source.length();
source.append(buffer);
for (Iterator<TypeDeclaration> iterator = compilationUnit.types().iterator(); iterator
.hasNext();) {
AbstractTypeDeclaration typeDeclaration = iterator.next();
if (Flags.isPublic(typeDeclaration.getModifiers())) {
fCompilationUnitName = typeDeclaration.getName()
.getIdentifier();
}
if (!fLastTypeName
.equals(typeDeclaration.getName().getIdentifier())) {
if (typeDeclaration instanceof TypeDeclaration) {
source.append(buildTypeDeclaration(null,
(TypeDeclaration) typeDeclaration));
} else if (typeDeclaration instanceof EnumDeclaration) {
source.append(buildEnumDeclaration(null,
(EnumDeclaration) typeDeclaration));
}
}
}
if (fCompilationUnitName == null) {
// If no public class was found, the compilation unit
// name doesn't matter.
fCompilationUnitName = "Eval"; //$NON-NLS-1$
}
return source;
}
/**
* Returns a method name that will be unique in the generated source. The
* generated name is baseName plus as many '_' characters as necessary to
* not duplicate an existing method name.
*
* @param methodName
* the method name to look for
* @param bodyDeclarations
* the listing of {@link BodyDeclaration}s to search through
* @return the unique method name
*/
private String getUniqueMethodName(String methodName, List<BodyDeclaration> bodyDeclarations) {
Iterator<BodyDeclaration> iter = bodyDeclarations.iterator();
BodyDeclaration bodyDeclaration;
MethodDeclaration method;
String foundName;
while (iter.hasNext()) {
bodyDeclaration = iter.next();
if (bodyDeclaration instanceof MethodDeclaration) {
method = (MethodDeclaration) bodyDeclaration;
foundName = method.getName().getIdentifier();
if (foundName.startsWith(methodName)) {
methodName = foundName + '_';
}
}
}
return methodName;
}
/**
* Returns a field name that will be unique in the generated source. The
* generated name is baseName plus as many '_' characters as necessary to
* not duplicate an existing method name.
*
* @param fieldName
* the name of the field to look for
* @param bodyDeclarations
* the list of {@link BodyDeclaration}s to search through
* @return the unique field name
*/
private String getUniqueFieldName(String fieldName, List<BodyDeclaration> bodyDeclarations) {
Iterator<BodyDeclaration> iter = bodyDeclarations.iterator();
BodyDeclaration bodyDeclaration;
FieldDeclaration fieldDeclaration;
String foundName;
while (iter.hasNext()) {
bodyDeclaration = iter.next();
if (bodyDeclaration instanceof FieldDeclaration) {
fieldDeclaration = (FieldDeclaration) bodyDeclaration;
for (Iterator<VariableDeclarationFragment> iterator = fieldDeclaration.fragments()
.iterator(); iterator.hasNext();) {
foundName = iterator.next()
.getName().getIdentifier();
if (foundName.startsWith(fieldName)) {
fieldName = foundName + '_';
}
}
}
}
return fieldName;
}
private String getQualifiedIdentifier(Name name) {
String typeName = ""; //$NON-NLS-1$
while (name.isQualifiedName()) {
QualifiedName qualifiedName = (QualifiedName) name;
typeName = "." + qualifiedName.getName().getIdentifier() + typeName; //$NON-NLS-1$
name = qualifiedName.getQualifier();
}
if (name.isSimpleName()) {
typeName = ((SimpleName) name).getIdentifier() + typeName;
} else {
return null;
}
return typeName;
}
public String getTypeName(Type type) {
if (type.isSimpleType()) {
String name = getQualifiedIdentifier(((SimpleType) type).getName());
if (!isSourceLevelGreaterOrEqual(1, 5)
&& fTypeParameterStack.peek().containsKey(name)) {
return "Object"; //$NON-NLS-1$
}
return name;
} else if (type.isArrayType()) {
return getTypeName(((ArrayType) type).getComponentType()) + "[]"; //$NON-NLS-1$
} else if (type.isPrimitiveType()) {
return ((PrimitiveType) type).getPrimitiveTypeCode().toString();
} else if (type.isQualifiedType()) {
QualifiedType qualifiedType = (QualifiedType) type;
return getTypeName(qualifiedType.getQualifier()) + '.'
+ qualifiedType.getName().getIdentifier();
} else if (type.isParameterizedType()) {
ParameterizedType parameterizedType = (ParameterizedType) type;
StringBuffer buff = new StringBuffer(
getTypeName(parameterizedType.getType()));
Iterator<Type> iter = parameterizedType.typeArguments().iterator();
if (iter.hasNext() && isSourceLevelGreaterOrEqual(1, 5)) {
buff.append('<');
buff.append(getTypeName(iter.next()));
while (iter.hasNext()) {
buff.append(',');
buff.append(getTypeName(iter.next()));
}
buff.append('>');
}
return buff.toString();
} else if (type.isWildcardType()) {
WildcardType wildcardType = (WildcardType) type;
StringBuffer buff = new StringBuffer("?"); //$NON-NLS-1$
Type bound = wildcardType.getBound();
if (bound != null) {
buff.append(wildcardType.isUpperBound() ? " extends " : " super "); //$NON-NLS-1$ //$NON-NLS-2$
buff.append(getTypeName(bound));
}
return buff.toString();
}
return null;
}
public String getReturnExpression(Type type) {
if (type.isSimpleType() || type.isArrayType() || type.isQualifiedType()
|| type.isWildcardType() || type.isParameterizedType()) {
return "return null;"; //$NON-NLS-1$
} else if (type.isPrimitiveType()) {
String typeName = ((PrimitiveType) type).getPrimitiveTypeCode()
.toString();
char char0 = typeName.charAt(0);
if (char0 == 'v') {
return ""; //$NON-NLS-1$
}
char char1 = typeName.charAt(1);
if (char0 == 'b' && char1 == 'o') {
return "return false;"; //$NON-NLS-1$
}
return "return 0;"; //$NON-NLS-1$
}
return null;
}
// ----------------------
/**
* @see ASTVisitor#endVisit(ClassInstanceCreation)
*/
@Override
public void endVisit(ClassInstanceCreation node) {
if (hasError()) {
return;
}
AnonymousClassDeclaration anonymousClassDeclaration = node
.getAnonymousClassDeclaration();
if (anonymousClassDeclaration != null) {
if (!rightTypeFound() && isRightType(node)) {
setRightTypeFound(true);
fSource = buildRunMethod(anonymousClassDeclaration
.bodyDeclarations());
fEvaluateNextEndTypeDeclaration = true;
}
if (rightTypeFound()) {
List<BodyDeclaration> bodyDeclarations = anonymousClassDeclaration
.bodyDeclarations();
StringBuffer source = buildTypeBody(fSource, bodyDeclarations);
ASTNode parent = node.getParent();
while (!(parent instanceof MethodDeclaration
|| parent instanceof FieldDeclaration || parent instanceof Initializer)
&& parent != null) {
parent = parent.getParent();
}
fSource = new StringBuffer();
if (parent instanceof Initializer) {
buildAnonymousEvalMethod(true, bodyDeclarations,
getTypeName(node.getType()), source);
} else if (parent instanceof MethodDeclaration) {
MethodDeclaration enclosingMethodDeclaration = (MethodDeclaration) parent;
buildAnonymousEvalMethod(
Flags.isStatic(enclosingMethodDeclaration
.getModifiers()), bodyDeclarations,
getTypeName(node.getType()), source);
} else if (parent instanceof FieldDeclaration) {
FieldDeclaration enclosingFieldDeclaration = (FieldDeclaration) parent;
if (Flags
.isStatic(enclosingFieldDeclaration.getModifiers())) {
fSource.append("static "); //$NON-NLS-1$
}
Type type = getParentType(enclosingFieldDeclaration
.getType());
fSource.append(getQualifiedIdentifier(((SimpleType) type)
.getName()));
fSource.append(' ');
fSource.append(getUniqueFieldName(EVAL_FIELD_NAME,
bodyDeclarations));
fSource.append(" = new "); //$NON-NLS-1$
fSource.append(getTypeName(node.getType()));
fSource.append("()"); //$NON-NLS-1$
fSnippetStartPosition += fSource.length();
fSource.append(source);
fSource.append(";\n"); //$NON-NLS-1$
}
fLastTypeName = ""; //$NON-NLS-1$
}
}
}
/**
* Create a <code>void ____eval()</code> method considering the given
* {@link BodyDeclaration}s, type name and existing body source when an
* anonymous {@link ClassInstanceCreation} is visited. <br>
* <br>
* This method adds the new <code>___eval</code> method source to the root
* {@link #fSource} variable directly
*
* @param isstatic
* if the keyword <code>static</code> should be added to the
* method source
* @param bodydecls
* the existing listing of {@link BodyDeclaration}s to consider
* when creating the <code>___eval</code> method name
* @param typename
* the raw type name of the type to instantiate in the
* <code>___eval</code> method
* @param body
* the existing body of source to append to the remainder of the
* new method
* @since 3.7
*/
void buildAnonymousEvalMethod(boolean isstatic, List<BodyDeclaration> bodydecls,
String typename, StringBuffer body) {
if (isstatic) {
fSource.append("static "); //$NON-NLS-1$
}
adddTypeParameters(fSource);
fSource.append("void "); //$NON-NLS-1$
fSource.append(getUniqueMethodName(EVAL_METHOD_NAME, bodydecls));
fSource.append("() {\n"); //$NON-NLS-1$
fSource.append("new "); //$NON-NLS-1$
fSource.append(typename);
fSource.append("()"); //$NON-NLS-1$
fSnippetStartPosition += fSource.length();
fSource.append(body);
fSource.append(";}\n"); //$NON-NLS-1$
}
/**
* Recursively finds the parent {@link Type} from the given type, in the
* cases where the type is an {@link ArrayType} or a
* {@link ParameterizedType}
*
* @param type
* the {@link Type}
* @return the parent {@link Type}
*/
private Type getParentType(Type type) {
if (type instanceof ArrayType) {
return getParentType(((ArrayType) type).getComponentType());
}
if (type instanceof ParameterizedType) {
return getParentType(((ParameterizedType) type).getType());
}
return type;
}
/**
* @see ASTVisitor#endVisit(CompilationUnit)
*/
@Override
public void endVisit(CompilationUnit node) {
if (hasError()) {
return;
}
if (!rightTypeFound()) { // if the right type hasn't been found
fSource = null;
return;
}
fSource = buildCompilationUnit(fSource, node);
}
/*
* (non-Javadoc)
*
* @see
* org.eclipse.jdt.core.dom.ASTVisitor#endVisit(org.eclipse.jdt.core.dom
* .EnumDeclaration)
*/
@Override
public void endVisit(EnumDeclaration node) {
if (hasError()) {
return;
}
if (!rightTypeFound() && isRightType(node)) {
setRightTypeFound(true);
fSource = buildRunMethod(node.bodyDeclarations());
fEvaluateNextEndTypeDeclaration = true;
}
if (!fEvaluateNextEndTypeDeclaration) {
fEvaluateNextEndTypeDeclaration = true;
return;
}
if (rightTypeFound()) {
StringBuffer source = buildEnumDeclaration(fSource, node);
if (node.isLocalTypeDeclaration()) {
// enclose in a method if necessary
ASTNode parent = node.getParent();
while (!(parent instanceof MethodDeclaration)) {
parent = parent.getParent();
}
MethodDeclaration enclosingMethodDeclaration = (MethodDeclaration) parent;
fSource = new StringBuffer();
if (Flags.isStatic(enclosingMethodDeclaration.getModifiers())) {
fSource.append("static "); //$NON-NLS-1$
}
fSource.append("void ___eval() {\n"); //$NON-NLS-1$
fSnippetStartPosition += fSource.length();
fSource.append(source);
fSource.append("}\n"); //$NON-NLS-1$
fLastTypeName = ""; //$NON-NLS-1$
} else {
fSource = source;
fLastTypeName = node.getName().getIdentifier();
}
}
}
/* (non-Javadoc)
* @see org.eclipse.jdt.core.dom.ASTVisitor#endVisit(org.eclipse.jdt.core.dom.MethodDeclaration)
*/
@Override
public void endVisit(MethodDeclaration node) {
fTypeParameterStack.pop();
}
/**
* @see ASTVisitor#endVisit(TypeDeclaration)
*/
@Override
public void endVisit(TypeDeclaration node) {
if (hasError()) {
fTypeParameterStack.pop();
return;
}
if (!rightTypeFound() && isRightType(node)) {
setRightTypeFound(true);
fSource = buildRunMethod(node.bodyDeclarations());
fEvaluateNextEndTypeDeclaration = true;
}
if (!fEvaluateNextEndTypeDeclaration) {
fEvaluateNextEndTypeDeclaration = true;
fTypeParameterStack.pop();
return;
}
if (rightTypeFound()) {
StringBuffer source = buildTypeDeclaration(fSource, node);
if (node.isLocalTypeDeclaration()) {
// enclose in a method if nessecary
ASTNode parent = node.getParent();
while (!(parent instanceof MethodDeclaration)) {
parent = parent.getParent();
}
MethodDeclaration enclosingMethodDeclaration = (MethodDeclaration) parent;
fSource = new StringBuffer();
if (Flags.isStatic(enclosingMethodDeclaration.getModifiers())) {
fSource.append("static "); //$NON-NLS-1$
}
fSource.append("void ___eval() {\n"); //$NON-NLS-1$
fSnippetStartPosition += fSource.length();
fSource.append(source);
fSource.append("}\n"); //$NON-NLS-1$
fLastTypeName = ""; //$NON-NLS-1$
} else {
fSource = source;
fLastTypeName = node.getName().getIdentifier();
}
}
fTypeParameterStack.pop();
}
/*
* (non-Javadoc)
*
* @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.
* AnnotationTypeDeclaration)
*/
@Override
public boolean visit(AnnotationTypeDeclaration node) {
return false;
}
/*
* (non-Javadoc)
*
* @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.
* AnnotationTypeMemberDeclaration)
*/
@Override
public boolean visit(AnnotationTypeMemberDeclaration node) {
return false;
}
/**
* @see ASTVisitor#visit(AnonymousClassDeclaration)
*/
@Override
public boolean visit(AnonymousClassDeclaration node) {
if (rightTypeFound()) {
return false;
}
return true;
}
/**
* @see ASTVisitor#visit(ArrayAccess)
*/
@Override
public boolean visit(ArrayAccess node) {
if (rightTypeFound()) {
return false;
}
return true;
}
/**
* @see ASTVisitor#visit(ArrayCreation)
*/
@Override
public boolean visit(ArrayCreation node) {
if (rightTypeFound()) {
return false;
}
return true;
}
/**
* @see ASTVisitor#visit(ArrayInitializer)
*/
@Override
public boolean visit(ArrayInitializer node) {
if (rightTypeFound()) {
return false;
}
return true;
}
/**
* @see ASTVisitor#visit(ArrayType)
*/
@Override
public boolean visit(ArrayType node) {
if (rightTypeFound()) {
return false;
}
return true;
}
/**
* @see ASTVisitor#visit(AssertStatement)
*/
@Override
public boolean visit(AssertStatement node) {
if (rightTypeFound()) {
return false;
}
return true;
}
/**
* @see ASTVisitor#visit(Assignment)
*/
@Override
public boolean visit(Assignment node) {
if (rightTypeFound()) {
return false;
}
return true;
}
/**
* @see ASTVisitor#visit(Block)
*/
@Override
public boolean visit(Block node) {
if (rightTypeFound()) {
return false;
}
return true;
}
/*
* (non-Javadoc)
*
* @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.
* BlockComment)
*/
@Override
public boolean visit(BlockComment node) {
return false;
}
/**
* @see ASTVisitor#visit(BooleanLiteral)
*/
@Override
public boolean visit(BooleanLiteral node) {
if (rightTypeFound()) {
return false;
}
return true;
}
/**
* @see ASTVisitor#visit(BreakStatement)
*/
@Override
public boolean visit(BreakStatement node) {
if (rightTypeFound()) {
return false;
}
return true;
}
/**
* @see ASTVisitor#visit(CastExpression)
*/
@Override
public boolean visit(CastExpression node) {
if (rightTypeFound()) {
return false;
}
return true;
}
/**
* @see ASTVisitor#visit(CatchClause)
*/
@Override
public boolean visit(CatchClause node) {
if (rightTypeFound()) {
return false;
}
return true;
}
/**
* @see ASTVisitor#visit(CharacterLiteral)
*/
@Override
public boolean visit(CharacterLiteral node) {
if (rightTypeFound()) {
return false;
}
return true;
}
/**
* @see ASTVisitor#visit(ClassInstanceCreation)
*/
@Override
public boolean visit(ClassInstanceCreation node) {
if (rightTypeFound()) {
return false;
}
return true;
}
/**
* @see ASTVisitor#visit(CompilationUnit)
*/
@Override
public boolean visit(CompilationUnit node) {
fCompilationUnit = node;
if (rightTypeFound()) {
return false;
}
return true;
}
/**
* @see ASTVisitor#visit(ConditionalExpression)
*/
@Override
public boolean visit(ConditionalExpression node) {
if (rightTypeFound()) {
return false;
}
return true;
}
/**
* @see ASTVisitor#visit(ConstructorInvocation)
*/
@Override
public boolean visit(ConstructorInvocation node) {
if (rightTypeFound()) {
return false;
}
return true;
}
/**
* @see ASTVisitor#visit(ContinueStatement)
*/
@Override
public boolean visit(ContinueStatement node) {
if (rightTypeFound()) {
return false;
}
return true;
}
/**
* @see ASTVisitor#visit(DoStatement)
*/
@Override
public boolean visit(DoStatement node) {
if (rightTypeFound()) {
return false;
}
return true;
}
/**
* @see ASTVisitor#visit(EmptyStatement)
*/
@Override
public boolean visit(EmptyStatement node) {
if (rightTypeFound()) {
return false;
}
return true;
}
/*
* (non-Javadoc)
*
* @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.
* EnhancedForStatement)
*/
@Override
public boolean visit(EnhancedForStatement node) {
if (rightTypeFound()) {
return false;
}
return true;
}
/*
* (non-Javadoc)
*
* @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.
* EnumConstantDeclaration)
*/
@Override
public boolean visit(EnumConstantDeclaration node) {
if (rightTypeFound()) {
return false;
}
return true;
}
/*
* (non-Javadoc)
*
* @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.
* EnumDeclaration)
*/
@Override
public boolean visit(EnumDeclaration node) {
if (rightTypeFound()) {
fEvaluateNextEndTypeDeclaration = false;
return false;
}
return true;
}
/**
* @see ASTVisitor#visit(ExpressionStatement)
*/
@Override
public boolean visit(ExpressionStatement node) {
if (rightTypeFound()) {
return false;
}
return true;
}
/**
* @see ASTVisitor#visit(FieldAccess)
*/
@Override
public boolean visit(FieldAccess node) {
if (rightTypeFound()) {
return false;
}
return true;
}
/**
* @see ASTVisitor#visit(FieldDeclaration)
*/
@Override
public boolean visit(FieldDeclaration node) {
if (rightTypeFound()) {
return false;
}
return true;
}
/**
* @see ASTVisitor#visit(ForStatement)
*/
@Override
public boolean visit(ForStatement node) {
if (rightTypeFound()) {
return false;
}
return true;
}
/**
* @see ASTVisitor#visit(IfStatement)
*/
@Override
public boolean visit(IfStatement node) {
if (rightTypeFound()) {
return false;
}
return true;
}
/**
* @see ASTVisitor#visit(ImportDeclaration)
*/
@Override
public boolean visit(ImportDeclaration node) {
if (rightTypeFound()) {
return false;
}
return true;
}
/**
* @see ASTVisitor#visit(InfixExpression)
*/
@Override
public boolean visit(InfixExpression node) {
if (rightTypeFound()) {
return false;
}
return true;
}
/**
* @see ASTVisitor#visit(Initializer)
*/
@Override
public boolean visit(Initializer node) {
if (rightTypeFound()) {
return false;
}
return true;
}
/*
* (non-Javadoc)
*
* @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.
* InstanceofExpression)
*/
@Override
public boolean visit(InstanceofExpression node) {
if (rightTypeFound()) {
return false;
}
return true;
}
/**
* @see ASTVisitor#visit(Javadoc)
*/
@Override
public boolean visit(Javadoc node) {
if (rightTypeFound()) {
return false;
}
return true;
}
/**
* @see ASTVisitor#visit(LabeledStatement)
*/
@Override
public boolean visit(LabeledStatement node) {
if (rightTypeFound()) {
return false;
}
return true;
}
/*
* (non-Javadoc)
*
* @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.
* LineComment)
*/
@Override
public boolean visit(LineComment node) {
return false;
}
/*
* (non-Javadoc)
*
* @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.
* MarkerAnnotation)
*/
@Override
public boolean visit(MarkerAnnotation node) {
return false;
}
/*
* (non-Javadoc)
*
* @see
* org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.MemberRef
* )
*/
@Override
public boolean visit(MemberRef node) {
return false;
}
/*
* (non-Javadoc)
*
* @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.
* MemberValuePair)
*/
@Override
public boolean visit(MemberValuePair node) {
return false;
}
/**
* @see ASTVisitor#visit(MethodDeclaration)
*/
@Override
public boolean visit(MethodDeclaration node) {
int firstLine = fCompilationUnit.getLineNumber(node.getStartPosition());
int lastLine = fCompilationUnit.getLineNumber(node.getStartPosition() + node.getLength());
List<TypeParameter> typeParameters = node.typeParameters();
pushTypeParameters(typeParameters);
if (isRightType(node.getParent()) && firstLine <= fLine && fLine <= lastLine) {
fMatchingTypeParameters = fTypeParameterStack.peek();
}
if (rightTypeFound()) {
return false;
}
return true;
}
private void pushTypeParameters(List<TypeParameter> typeParameters) {
if (!typeParameters.isEmpty()) {
HashMap<String,String> newTypeParameters = new HashMap<>(fTypeParameterStack.peek());
Iterator<TypeParameter> iterator = typeParameters.iterator();
while (iterator.hasNext()) {
TypeParameter typeParameter = iterator.next();
String boundName = typeParameter.getName().getIdentifier();
newTypeParameters.put(boundName, typeParameter.toString());
}
fTypeParameterStack.push(newTypeParameters); // Push the new "scope"
} else {
fTypeParameterStack.push(fTypeParameterStack.peek()); // Push the same
}
}
/**
* @see ASTVisitor#visit(MethodInvocation)
*/
@Override
public boolean visit(MethodInvocation node) {
if (rightTypeFound()) {
return false;
}
return true;
}
/*
* (non-Javadoc)
*
* @see
* org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.MethodRef
* )
*/
@Override
public boolean visit(MethodRef node) {
return false;
}
/*
* (non-Javadoc)
*
* @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.
* MethodRefParameter)
*/
@Override
public boolean visit(MethodRefParameter node) {
return false;
}
/*
* (non-Javadoc)
*
* @see
* org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.Modifier
* )
*/
@Override
public boolean visit(Modifier node) {
return false;
}
/*
* (non-Javadoc)
*
* @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.
* NormalAnnotation)
*/
@Override
public boolean visit(NormalAnnotation node) {
return false;
}
/**
* @see ASTVisitor#visit(NullLiteral)
*/
@Override
public boolean visit(NullLiteral node) {
if (rightTypeFound()) {
return false;
}
return true;
}
/**
* @see ASTVisitor#visit(NumberLiteral)
*/
@Override
public boolean visit(NumberLiteral node) {
if (rightTypeFound()) {
return false;
}
return true;
}
/**
* @see ASTVisitor#visit(PackageDeclaration)
*/
@Override
public boolean visit(PackageDeclaration node) {
if (rightTypeFound()) {
return false;
}
return true;
}
/*
* (non-Javadoc)
*
* @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.
* ParameterizedType)
*/
@Override
public boolean visit(ParameterizedType node) {
if (rightTypeFound()) {
return false;
}
return true;
}
/**
* @see ASTVisitor#visit(ParenthesizedExpression)
*/
@Override
public boolean visit(ParenthesizedExpression node) {
if (rightTypeFound()) {
return false;
}
return true;
}
/**
* @see ASTVisitor#visit(PostfixExpression)
*/
@Override
public boolean visit(PostfixExpression node) {
if (rightTypeFound()) {
return false;
}
return true;
}
/**
* @see ASTVisitor#visit(PrefixExpression)
*/
@Override
public boolean visit(PrefixExpression node) {
if (rightTypeFound()) {
return false;
}
return true;
}
/**
* @see ASTVisitor#visit(PrimitiveType)
*/
@Override
public boolean visit(PrimitiveType node) {
if (rightTypeFound()) {
return false;
}
return true;
}
/**
* @see ASTVisitor#visit(QualifiedName)
*/
@Override
public boolean visit(QualifiedName node) {
if (rightTypeFound()) {
return false;
}
return true;
}
/*
* (non-Javadoc)
*
* @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.
* QualifiedType)
*/
@Override
public boolean visit(QualifiedType node) {
return false;
}
/**
* @see ASTVisitor#visit(ReturnStatement)
*/
@Override
public boolean visit(ReturnStatement node) {
if (rightTypeFound()) {
return false;
}
return true;
}
/**
* @see ASTVisitor#visit(SimpleName)
*/
@Override
public boolean visit(SimpleName node) {
if (rightTypeFound()) {
return false;
}
return true;
}
/**
* @see ASTVisitor#visit(SimpleType)
*/
@Override
public boolean visit(SimpleType node) {
if (rightTypeFound()) {
return false;
}
return true;
}
/*
* (non-Javadoc)
*
* @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.
* SingleMemberAnnotation)
*/
@Override
public boolean visit(SingleMemberAnnotation node) {
return false;
}
/**
* @see ASTVisitor#visit(SingleVariableDeclaration)
*/
@Override
public boolean visit(SingleVariableDeclaration node) {
if (rightTypeFound()) {
return false;
}
return true;
}
/**
* @see ASTVisitor#visit(StringLiteral)
*/
@Override
public boolean visit(StringLiteral node) {
if (rightTypeFound()) {
return false;
}
return true;
}
/**
* @see ASTVisitor#visit(SuperConstructorInvocation)
*/
@Override
public boolean visit(SuperConstructorInvocation node) {
if (rightTypeFound()) {
return false;
}
return true;
}
/**
* @see ASTVisitor#visit(SuperFieldAccess)
*/
@Override
public boolean visit(SuperFieldAccess node) {
if (rightTypeFound()) {
return false;
}
return true;
}
/**
* @see ASTVisitor#visit(SuperMethodInvocation)
*/
@Override
public boolean visit(SuperMethodInvocation node) {
if (rightTypeFound()) {
return false;
}
return true;
}
/**
* @see ASTVisitor#visit(SwitchCase)
*/
@Override
public boolean visit(SwitchCase node) {
if (rightTypeFound()) {
return false;
}
return true;
}
/**
* @see ASTVisitor#visit(SwitchStatement)
*/
@Override
public boolean visit(SwitchStatement node) {
if (rightTypeFound()) {
return false;
}
return true;
}
/**
* @see ASTVisitor#visit(SynchronizedStatement)
*/
@Override
public boolean visit(SynchronizedStatement node) {
if (rightTypeFound()) {
return false;
}
return true;
}
/*
* (non-Javadoc)
*
* @see
* org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.TagElement
* )
*/
@Override
public boolean visit(TagElement node) {
return false;
}
/*
* (non-Javadoc)
*
* @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.
* TextElement)
*/
@Override
public boolean visit(TextElement node) {
return false;
}
/**
* @see ASTVisitor#visit(ThisExpression)
*/
@Override
public boolean visit(ThisExpression node) {
if (rightTypeFound()) {
return false;
}
return true;
}
/**
* @see ASTVisitor#visit(ThrowStatement)
*/
@Override
public boolean visit(ThrowStatement node) {
if (rightTypeFound()) {
return false;
}
return true;
}
/**
* @see ASTVisitor#visit(TryStatement)
*/
@Override
public boolean visit(TryStatement node) {
if (rightTypeFound()) {
return false;
}
return true;
}
/*
* (non-Javadoc)
*
* @see
* org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.UnionType
* )
*/
@Override
public boolean visit(UnionType node) {
if (rightTypeFound()) {
return false;
}
return true;
}
/**
* @see ASTVisitor#visit(TypeDeclaration)
*/
@Override
public boolean visit(TypeDeclaration node) {
List<TypeParameter> typeParameters = node.typeParameters();
pushTypeParameters(typeParameters);
if (rightTypeFound()) {
fEvaluateNextEndTypeDeclaration = false;
return false;
}
return true;
}
/**
* @see ASTVisitor#visit(TypeDeclarationStatement)
*/
@Override
public boolean visit(TypeDeclarationStatement node) {
if (rightTypeFound()) {
return false;
}
return true;
}
/**
* @see ASTVisitor#visit(TypeLiteral)
*/
@Override
public boolean visit(TypeLiteral node) {
if (rightTypeFound()) {
return false;
}
return true;
}
/*
* (non-Javadoc)
*
* @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.
* TypeParameter)
*/
@Override
public boolean visit(TypeParameter node) {
return false;
}
/**
* @see ASTVisitor#visit(VariableDeclarationExpression)
*/
@Override
public boolean visit(VariableDeclarationExpression node) {
if (rightTypeFound()) {
return false;
}
return true;
}
/**
* @see ASTVisitor#visit(VariableDeclarationFragment)
*/
@Override
public boolean visit(VariableDeclarationFragment node) {
if (rightTypeFound()) {
return false;
}
return true;
}
/**
* @see ASTVisitor#visit(VariableDeclarationStatement)
*/
@Override
public boolean visit(VariableDeclarationStatement node) {
if (rightTypeFound()) {
return false;
}
return true;
}
/**
* @see ASTVisitor#visit(WhileStatement)
*/
@Override
public boolean visit(WhileStatement node) {
if (rightTypeFound()) {
return false;
}
return true;
}
/*
* (non-Javadoc)
*
* @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.
* WildcardType)
*/
@Override
public boolean visit(WildcardType node) {
return false;
}
/**
* Returns whether the source to be generated is greater than or equal to
* the given source level.
*
* @param major
* major level - e.g. 1 from 1.4
* @param minor
* minor level - e.g. 4 from 1.4
* @return <code>true</code> if the given major / minor version is less than
* or equal to the backing source level
*/
public boolean isSourceLevelGreaterOrEqual(int major, int minor) {
return (fSourceMajorLevel > major)
|| (fSourceMajorLevel == major && fSourceMinorLevel >= minor);
}
/**
* Appends type parameters to source.
*
* @param source
* the current buffer of source to append to
* @param typeParameters
* the list of {@link TypeParameter}s to add
*/
private void appendTypeParameters(StringBuffer source, List<TypeParameter> typeParameters) {
if (!typeParameters.isEmpty() && isSourceLevelGreaterOrEqual(1, 5)) {
source.append('<');
Iterator<TypeParameter> iter = typeParameters.iterator();
TypeParameter typeParameter = iter.next();
source.append(typeParameter.getName().getIdentifier());
List<Type> typeBounds = typeParameter.typeBounds();
if (!typeBounds.isEmpty()) {
source.append(" extends "); //$NON-NLS-1$
Iterator<Type> iter2 = typeBounds.iterator();
source.append(getTypeName(iter2.next()));
while (iter2.hasNext()) {
source.append('&');
source.append(getTypeName(iter2.next()));
}
}
while (iter.hasNext()) {
source.append(',');
typeParameter = iter.next();
source.append(typeParameter.getName().getIdentifier());
typeBounds = typeParameter.typeBounds();
if (!typeBounds.isEmpty()) {
source.append(" extends "); //$NON-NLS-1$
Iterator<Type> iter2 = typeBounds.iterator();
source.append(getTypeName(iter2.next()));
while (iter2.hasNext()) {
source.append('&');
source.append(getTypeName(iter2.next()));
}
}
}
source.append('>');
source.append(' ');
}
}
}