ASTUtil.java

/*
 * Copyright (c) 2012 Andrejs Jermakovics.
 *
 * 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:
 *     Andrejs Jermakovics - initial implementation
 */
package jmockit.assist;

import java.util.Arrays;
import java.util.Collection;
import java.util.Comparator;
import java.util.List;
import java.util.Set;
import java.util.TreeSet;

import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.ITypeRoot;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.core.dom.AST;
import org.eclipse.jdt.core.dom.ASTNode;
import org.eclipse.jdt.core.dom.ASTParser;
import org.eclipse.jdt.core.dom.Annotation;
import org.eclipse.jdt.core.dom.ClassInstanceCreation;
import org.eclipse.jdt.core.dom.CompilationUnit;
import org.eclipse.jdt.core.dom.IAnnotationBinding;
import org.eclipse.jdt.core.dom.IMethodBinding;
import org.eclipse.jdt.core.dom.ITypeBinding;
import org.eclipse.jdt.core.dom.MethodDeclaration;
import org.eclipse.jdt.core.dom.ParameterizedType;
import org.eclipse.jdt.core.dom.Type;
import org.eclipse.jdt.core.dom.TypeDeclaration;
import org.eclipse.jdt.core.dom.rewrite.ASTRewrite;
import org.eclipse.jdt.internal.corext.dom.Bindings;
import org.eclipse.jdt.internal.corext.util.JavaModelUtil;
import org.eclipse.jdt.ui.SharedASTProvider;

@SuppressWarnings("restriction")
public class ASTUtil
{
	public static ITypeBinding getFirstTypeParameter(final ASTNode node)
	{
		ITypeBinding declaringType = null;

		if( node.getParent() instanceof ClassInstanceCreation ) // for anonymous
		{
			ClassInstanceCreation creation = (ClassInstanceCreation) node.getParent();
			Type ctype = creation.getType();

			declaringType = getFirstTypeParam(ctype);
		}
		else if( node instanceof TypeDeclaration )
		{
			Type ctype = ((TypeDeclaration) node).getSuperclassType();
			declaringType = getFirstTypeParam(ctype);
		}

		return declaringType;
	}

	@SuppressWarnings("unchecked")
	public static ITypeBinding getFirstTypeParam(final Type ctype)
	{
		ITypeBinding declaringType = null;

		if( ctype instanceof ParameterizedType )
		{
			ParameterizedType paramType = (ParameterizedType) ctype;
			List<Type> typeArgs = paramType.typeArguments();

			if( !typeArgs.isEmpty() )
			{
				Type arg1 = typeArgs.get(0);
				declaringType = arg1.resolveBinding();
			}
		}
		return declaringType;
	}

	public static void addAnnotation(final String annotation,
			final IJavaProject project, final ASTRewrite rewrite, final MethodDeclaration decl,
			final IMethodBinding binding)
	{
		String version= project.getOption(JavaCore.COMPILER_COMPLIANCE, true);

		if (!binding.getDeclaringClass().isInterface()
				|| !JavaModelUtil.isVersionLessThan(version, JavaCore.VERSION_1_6))
		{
			final Annotation marker= rewrite.getAST().newMarkerAnnotation();
			marker.setTypeName(rewrite.getAST().newSimpleName(annotation)); //$NON-NLS-1$
			rewrite.getListRewrite(decl, MethodDeclaration.MODIFIERS2_PROPERTY).insertFirst(marker, null);
		}
	}

	public static boolean isAnnotationPresent(final IAnnotationBinding[] annotations, final String annName)
	{
		return findAnnotation(annotations, annName) != null;
	}

	public static IAnnotationBinding findAnnotation(final IAnnotationBinding[] annotations, final String annName)
	{
		for(IAnnotationBinding ann: annotations)
		{
			if( annName.equals( ann.getAnnotationType().getQualifiedName()) )
			{
				return ann;
			}
		}

		return null;
	}

	public static CompilationUnit getAstOrParse(final ITypeRoot iTypeRoot, final IProgressMonitor mon)
	{
		CompilationUnit cu = SharedASTProvider.getAST(iTypeRoot, SharedASTProvider.WAIT_NO, mon);

		if( cu == null && (mon == null || !mon.isCanceled()) )
		{
			cu = parse(iTypeRoot, mon);
		}

		return cu;
	}

	public static CompilationUnit parse(final ITypeRoot unit, final IProgressMonitor mon)
	{
		ASTParser parser = ASTParser.newParser(AST.JLS3);
		parser.setKind(ASTParser.K_COMPILATION_UNIT);
		parser.setSource(unit);
		parser.setProject(unit.getJavaProject());
		parser.setResolveBindings(true);
		parser.setStatementsRecovery(true);
		return (CompilationUnit) parser.createAST(mon); // parse
	}

	@SuppressWarnings("unchecked")
	public static <T extends ASTNode> T findAncestor(final ASTNode node, final Class<T> clazz)
	{
		ASTNode parent = node.getParent();
		while( parent != null )
		{
			if( parent.getClass() == clazz )
			{
				break;
			}
			parent = parent.getParent();
		}
		return (T) parent;
	}

	public static IMethodBinding findMethodInType(final ITypeBinding type, final String name,
			final ITypeBinding[] paramTypes)
	{
		IMethodBinding origMethod;

		if (type.isInterface())
		{
			origMethod = Bindings.findMethodInHierarchy(type, name, paramTypes);
		}
		else
		{
			origMethod = Bindings.findMethodInType(type, name, paramTypes);
		}

		return origMethod;
	}

	public static Set<String> getMethodSignatures(final ITypeBinding objType) throws JavaModelException
	{
		Set<String> methods = new TreeSet<String>();

		for(IMethodBinding m: objType.getDeclaredMethods() )
		{
			methods.add( getSig(m) );
		}

		return methods;
	}

	public static String getSig(final IMethodBinding m)
	{
		String sig = m.getKey().split(";", 2)[1]; // remove declaring type
		return m.getName() +  sig;
	}

	public static Collection<IMethodBinding> getAllMethods(final ITypeBinding paramType, final AST ast)
			throws JavaModelException
	{
		Set<IMethodBinding> methods = new TreeSet<IMethodBinding>(new Comparator<IMethodBinding>()
		{
			@Override
			public int compare(final IMethodBinding m1, final IMethodBinding m2)
			{
				return getSig(m1).compareTo( getSig(m2) );
			}
		});

		methods.addAll(Arrays.asList( paramType.getDeclaredMethods() ) );

		if( paramType.isInterface() )
		{
			ITypeBinding[] superTypes = Bindings.getAllSuperTypes(paramType);

			for(ITypeBinding superType: superTypes )
			{
				methods.addAll( Arrays.asList(superType.getDeclaredMethods()) );
			}

			ITypeBinding obj = ast.resolveWellKnownType(Object.class.getName());
			for(IMethodBinding m: obj.getDeclaredMethods())
			{
				if( !m.isConstructor() )
				{
					methods.add(m);
				}
			}
		}

		return methods;
	}
}