Java tutorial
// COPIED from spring-ide org.springframework.ide.eclipse.core.java.JdtUtils /******************************************************************************* * Copyright (c) 2012 - 2013 Pivotal 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: * Pivotal Software, Inc. - initial API and implementation *******************************************************************************/ package org.springsource.ide.eclipse.commons.core; import java.util.ArrayList; import java.util.Collections; import java.util.HashSet; import java.util.List; import java.util.Set; import org.eclipse.core.resources.IProject; import org.eclipse.core.resources.IResource; import org.eclipse.core.resources.ResourcesPlugin; import org.eclipse.core.runtime.CoreException; import org.eclipse.core.runtime.IPath; import org.eclipse.core.runtime.IProgressMonitor; import org.eclipse.core.runtime.IStatus; import org.eclipse.core.runtime.NullProgressMonitor; import org.eclipse.core.runtime.OperationCanceledException; import org.eclipse.core.runtime.Status; import org.eclipse.jdt.core.IClasspathEntry; import org.eclipse.jdt.core.ICompilationUnit; import org.eclipse.jdt.core.IField; import org.eclipse.jdt.core.IImportDeclaration; import org.eclipse.jdt.core.IJavaElement; import org.eclipse.jdt.core.IJavaModel; import org.eclipse.jdt.core.IJavaProject; import org.eclipse.jdt.core.IMethod; import org.eclipse.jdt.core.IType; import org.eclipse.jdt.core.ITypeParameter; import org.eclipse.jdt.core.JavaCore; import org.eclipse.jdt.core.JavaModelException; import org.eclipse.jdt.core.Signature; 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.ASTVisitor; import org.eclipse.jdt.launching.JavaRuntime; import org.springsource.ide.eclipse.commons.internal.core.CorePlugin; /** * Utility class that provides several helper methods for working with Eclipse's * JDT. * @author Christian Dupuis * @author Martin Lippert * @author Leo Dos Santos * @since 2.0 */ public class JdtUtils { public static final String CLASS_FILE_EXTENSION = ".class"; public static final String GROOVY_FILE_EXTENSION = ".groovy"; public static final String JAVA_FILE_EXTENSION = ".java"; private static final String AJDT_CLASS = "org.eclipse.ajdt.core.javaelements.AJCompilationUnitManager"; private static final String AJDT_NATURE = "org.eclipse.ajdt.ui.ajnature"; private static final String CLASSPATH_FILENAME = ".classpath"; private static final boolean IS_AJDT_PRESENT = isAjdtPresent(); /** Suffix for array class names: "[]" */ private static final String ARRAY_SUFFIX = "[]"; /** * Creates specified Java project. */ public static IJavaProject createJavaProject(String projectName, IProgressMonitor monitor) throws CoreException { IProject project = SpringCoreUtils.createProject(projectName, null, monitor); if (monitor.isCanceled()) { throw new OperationCanceledException(); } if (!project.hasNature(JavaCore.NATURE_ID)) { SpringCoreUtils.addProjectNature(project, JavaCore.NATURE_ID, monitor); } IJavaProject jproject = JavaCore.create(project); // append JRE entry jproject.setRawClasspath(new IClasspathEntry[] { getJreVariableEntry() }, monitor); jproject.setOutputLocation(project.getFullPath(), monitor); if (monitor.isCanceled()) { throw new OperationCanceledException(); } return jproject; } /** * Checks if the given <code>type</code> implements/extends * <code>className</code>. */ // public static boolean doesImplement(IResource resource, IType type, // String className) { // if (resource == null || type == null || className == null) { // return false; // } // if (className.startsWith("java.") || className.startsWith("javax.")) { // try { // ClassLoader cls = getClassLoader(resource.getProject(), null); // Class<?> typeClass = cls.loadClass(type.getFullyQualifiedName('$')); // Class<?> interfaceClass = cls.loadClass(className); // return typeClass.equals(interfaceClass) || // interfaceClass.isAssignableFrom(typeClass); // } // catch (Throwable e) { // // ignore this and fall back to JDT does implement checks // } // } // return doesImplementWithJdt(resource, type, className); // } // public static IType getAjdtType(IProject project, String className) { // IJavaProject javaProject = getJavaProject(project); // if (IS_AJDT_PRESENT && javaProject != null && className != null) { // // try { // IType type = null; // // // First look for the type in the project // if (isAjdtProject(project)) { // type = AjdtUtils.getAjdtType(project, className); // if (type != null) { // return type; // } // } // // // Then look for the type in the referenced Java projects // for (IProject refProject : project.getReferencedProjects()) { // if (isAjdtProject(refProject)) { // type = AjdtUtils.getAjdtType(refProject, className); // if (type != null) { // return type; // } // } // } // } // catch (CoreException e) { // StatusHandler.log(new Status(IStatus.ERROR, CorePlugin.PLUGIN_ID, // "Error getting Java type '" // + className + "'", e)); // } // } // return null; // } public static List<IJavaProject> getAllDependingJavaProjects(IJavaProject project) { List<IJavaProject> javaProjects = new ArrayList<IJavaProject>(); IJavaModel model = JavaCore.create(ResourcesPlugin.getWorkspace().getRoot()); if (model != null) { try { String[] names = project.getRequiredProjectNames(); IJavaProject[] projects = model.getJavaProjects(); for (IJavaProject project2 : projects) { for (String name2 : names) { String name = project2.getProject().getName(); if (name.equals(name2)) { javaProjects.add(project2); } } } } catch (JavaModelException exception) { } } return javaProjects; } /** * Creates a Set of {@link URL}s from the OSGi bundle class path manifest * entry. */ // public static Set<URL> getBundleClassPath(String bundleId) { // Set<URL> paths = new HashSet<URL>(); // try { // Bundle bundle = Platform.getBundle(bundleId); // if (bundle != null) { // String bundleClassPath = (String) bundle.getHeaders() // .get(org.osgi.framework.Constants.BUNDLE_CLASSPATH); // if (bundleClassPath != null) { // String[] classPathEntries = // StringUtils.delimitedListToStringArray(bundleClassPath, ","); // for (String classPathEntry : classPathEntries) { // if (".".equals(classPathEntry.trim())) { // paths.add(FileLocator.toFileURL(bundle.getEntry("/"))); // } // else { // paths.add(FileLocator.toFileURL(new URL(bundle.getEntry("/"), "/" + // classPathEntry.trim()))); // } // } // } // else { // paths.add(FileLocator.toFileURL(bundle.getEntry("/"))); // } // } // } // catch (MalformedURLException e) { // StatusHandler // .log(new Status(IStatus.ERROR, CorePlugin.PLUGIN_ID, // "An error occurred getting classpath", e)); // } // catch (IOException e) { // StatusHandler // .log(new Status(IStatus.ERROR, CorePlugin.PLUGIN_ID, // "An error occurred getting classpath", e)); // } // return paths; // } /** * @since 2.6.0 */ public static IJavaElement getByHandle(String handle) { // if (IS_AJDT_PRESENT) { // return AjdtUtils.getByHandle(handle); // } // else { return JavaCore.create(handle); // } } /** * Create a {@link ClassLoader} from the class path configuration of the * given <code>project</code>. * @param project the {@link IProject} * @param useParentClassLoader true if the current OSGi class loader should * be used as parent class loader for the constructed class loader. * @return {@link ClassLoader} instance constructed from the * <code>project</code>'s build path configuration */ // public static ClassLoader getClassLoader(IProject project, ClassLoader // parentClassLoader) { // return ProjectClassLoaderCache.getClassLoader(project, // parentClassLoader); // } // // public static void removeClassLoaderEntryFromCache(IProject project) { // ProjectClassLoaderCache.removeClassLoaderEntryFromCache(project); // } // // public static IMethod getConstructor(IType type, Class[] parameterTypes) // { // String[] parameterTypesAsString = // getParameterTypesAsStringArray(parameterTypes); // return getConstructor(type, parameterTypesAsString); // } // public static IMethod getConstructor(IType type, String[] parameterTypes) // { // try { // Set<IMethod> methods = Introspector.getAllConstructors(type); // for (IMethod method : methods) { // if (method.getParameterTypes().length == parameterTypes.length) { // String[] methodParameterTypes = getParameterTypesAsStringArray(method); // if (Arrays.deepEquals(parameterTypes, methodParameterTypes)) { // return method; // } // } // } // } // catch (JavaModelException e) { // } // return null; // } // public static IField getField(IType type, String fieldName, String // parameterType) { // try { // Set<IField> methods = Introspector.getAllFields(type); // for (IField field : methods) { // if (field.getElementName().equals(fieldName)) { // return field; // } // } // } // catch (JavaModelException e) { // } // return null; // } /** * Returns a flat list of all interfaces and super types for the given * {@link IType}. */ // public static List<String> getFlatListOfClassAndInterfaceNames(IType // parameterType, IType type) { // List<String> requiredTypes = new ArrayList<String>(); // if (parameterType != null) { // do { // try { // requiredTypes.add(parameterType.getFullyQualifiedName()); // String[] interfaceNames = parameterType.getSuperInterfaceNames(); // for (String interfaceName : interfaceNames) { // if (interfaceName != null) { // if (type.isBinary()) { // requiredTypes.add(interfaceName); // } // String resolvedName = resolveClassName(interfaceName, type); // if (resolvedName != null) { // requiredTypes.add(resolvedName); // } // } // } // parameterType = Introspector.getSuperType(parameterType); // } // catch (JavaModelException e) { // } // } while (parameterType != null && // !parameterType.getFullyQualifiedName().equals(Object.class.getName())); // } // return requiredTypes; // } /** * Returns the corresponding Java project or <code>null</code> a for given * project. * @param project the project the Java project is requested for * @return the requested Java project or <code>null</code> if the Java * project is not defined or the project is not accessible */ public static IJavaProject getJavaProject(IProject project) { if (project.isAccessible()) { try { if (project.hasNature(JavaCore.NATURE_ID)) { return (IJavaProject) project.getNature(JavaCore.NATURE_ID); } } catch (CoreException e) { StatusHandler.log(new Status(IStatus.ERROR, CorePlugin.PLUGIN_ID, "Error getting Java project for project '" + project.getName() + "'", e)); } } return null; } public static IJavaProject getJavaProject(IResource config) { IJavaProject project = JavaCore.create(config.getProject()); return project; } /** * Returns the corresponding Java type for given full-qualified class name. * @param project the JDT project the class belongs to * @param className the full qualified class name of the requested Java type * @return the requested Java type or null if the class is not defined or * the project is not accessible */ public static IType getJavaType(IProject project, String className) { IJavaProject javaProject = JdtUtils.getJavaProject(project); if (className != null) { // For inner classes replace '$' by '.' int pos = className.lastIndexOf('$'); if (pos > 0) { className = className.replace('$', '.'); } try { IType type = null; // First look for the type in the Java project if (javaProject != null) { // TODO CD not sure why we need type = javaProject.findType(className, new NullProgressMonitor()); // type = javaProject.findType(className); if (type != null) { return type; } } // Then look for the type in the referenced Java projects for (IProject refProject : project.getReferencedProjects()) { IJavaProject refJavaProject = JdtUtils.getJavaProject(refProject); if (refJavaProject != null) { type = refJavaProject.findType(className); if (type != null) { return type; } } } // fall back and try to locate the class using AJDT // TODO: uncomment this call // return getAjdtType(project, className); } catch (CoreException e) { StatusHandler.log(new Status(IStatus.ERROR, CorePlugin.PLUGIN_ID, "Error getting Java type '" + className + "'", e)); } } return null; } public static final IType getJavaTypeForMethodReturnType(IMethod method, IType contextType) { try { return JdtUtils.getJavaTypeFromSignatureClassName(method.getReturnType(), contextType); } catch (JavaModelException e) { } return null; } public static IType getJavaTypeFromSignatureClassName(String className, IType contextType) { if (contextType == null || className == null) { return null; } try { return JdtUtils.getJavaType(contextType.getJavaProject().getProject(), JdtUtils.resolveClassNameBySignature(className, contextType)); } catch (IllegalArgumentException e) { // do Nothing } return null; } @SuppressWarnings("unchecked") public static final List<IType> getJavaTypesForMethodParameterTypes(IMethod method, IType contextType) { if (method == null || method.getParameterTypes() == null || method.getParameterTypes().length == 0) { return Collections.EMPTY_LIST; } List<IType> parameterTypes = new ArrayList<IType>(method.getParameterTypes().length); String[] parameterTypeNames = method.getParameterTypes(); for (String parameterTypeName : parameterTypeNames) { parameterTypes.add(JdtUtils.getJavaTypeFromSignatureClassName(parameterTypeName, contextType)); } return parameterTypes; } public static IClasspathEntry getJreVariableEntry() { return JavaRuntime.getDefaultJREContainerEntry(); } public static int getLineNumber(IJavaElement element) { if (element != null && element instanceof IMethod) { try { IMethod method = (IMethod) element; int lines = 0; if (method.getDeclaringType() != null && method.getDeclaringType().getCompilationUnit() != null) { String targetsource = method.getDeclaringType().getCompilationUnit().getSource(); if (targetsource != null) { String sourceuptomethod = targetsource.substring(0, method.getNameRange().getOffset()); char[] chars = new char[sourceuptomethod.length()]; sourceuptomethod.getChars(0, sourceuptomethod.length(), chars, 0); for (char element0 : chars) { if (element0 == '\n') { lines++; } } return new Integer(lines + 1); } } } catch (JavaModelException e) { } } else if (element != null && element instanceof IType && ((IType) element).getCompilationUnit() != null) { try { IType type = (IType) element; int lines = 0; String targetsource = type.getCompilationUnit().getSource(); if (targetsource != null) { String sourceuptomethod = targetsource.substring(0, type.getNameRange().getOffset()); char[] chars = new char[sourceuptomethod.length()]; sourceuptomethod.getChars(0, sourceuptomethod.length(), chars, 0); for (char element0 : chars) { if (element0 == '\n') { lines++; } } return new Integer(lines + 1); } } catch (JavaModelException e) { } } else if (element != null && element instanceof IField) { try { IField type = (IField) element; int lines = 0; ICompilationUnit cu = type.getCompilationUnit(); if (cu != null) { String targetsource = cu.getSource(); if (targetsource != null) { String sourceuptomethod = targetsource.substring(0, type.getNameRange().getOffset()); char[] chars = new char[sourceuptomethod.length()]; sourceuptomethod.getChars(0, sourceuptomethod.length(), chars, 0); for (char element0 : chars) { if (element0 == '\n') { lines++; } } return new Integer(lines + 1); } } } catch (JavaModelException e) { } } return new Integer(-1); } // public static IMethod getMethod(IType type, String methodName, Class[] // parameterTypes) { // String[] parameterTypesAsString = // getParameterTypesAsStringArray(parameterTypes); // return getMethod(type, methodName, parameterTypesAsString); // } // public static IMethod getMethod(IType type, String methodName, String[] // parameterTypes) { // int index = methodName.indexOf('('); // if (index >= 0) { // methodName = methodName.substring(0, index); // } // try { // Set<IMethod> methods = Introspector.getAllMethods(type); // for (IMethod method : methods) { // if (method.getElementName().equals(methodName) // && method.getParameterTypes().length == parameterTypes.length) { // String[] methodParameterTypes = getParameterTypesAsStringArray(method); // if (Arrays.deepEquals(parameterTypes, methodParameterTypes)) { // return method; // } // } // } // // return Introspector.findMethod(type, methodName, parameterTypes.length, // Public.YES, Static.DONT_CARE); // } // catch (JavaModelException e) { // } // return null; // } public static String getMethodName(IMethod method) { // Special support Ajdt intertype declarations String methodName = method.getElementName(); int index = methodName.lastIndexOf('.'); if (index > 0) { methodName = methodName.substring(index + 1); } return methodName; } public static String[] getParameterTypesString(IMethod method) { try { String[] parameterQualifiedTypes = Signature.getParameterTypes(method.getSignature()); int length = parameterQualifiedTypes == null ? 0 : parameterQualifiedTypes.length; String[] parameterPackages = new String[length]; for (int i = 0; i < length; i++) { parameterQualifiedTypes[i] = parameterQualifiedTypes[i].replace('/', '.'); parameterPackages[i] = Signature.getSignatureSimpleName(parameterQualifiedTypes[i]); } return parameterPackages; } catch (IllegalArgumentException e) { } catch (JavaModelException e) { } return null; } public static String getParentName(IMethod method) { // Special support Ajdt intertype declarations String methodName = method.getElementName(); int index = methodName.lastIndexOf('.'); if (index > 0) { return methodName.substring(0, index); } else { return method.getParent().getElementName(); } } // public static IProjectClassLoaderSupport // getProjectClassLoaderSupport(IProject je, ClassLoader parentClassLoader) // { // return new DefaultProjectClassLoaderSupport(je, parentClassLoader); // } public static String getPropertyNameFromMethodName(IMethod method) { // Special support Ajdt intertype declarations String methodName = method.getElementName(); int index = methodName.lastIndexOf('.'); if (index > 0) { methodName = methodName.substring(index + 1); } String replaceText = methodName.substring("set".length()); if (replaceText != null) { replaceText = java.beans.Introspector.decapitalize(replaceText); } return replaceText; } public static String getReturnTypeString(IMethod method, boolean classTypesOnly) { try { String qualifiedReturnType = Signature.getReturnType(method.getSignature()); if (!classTypesOnly || qualifiedReturnType.startsWith("L") || qualifiedReturnType.startsWith("Q")) { return Signature.getSignatureSimpleName(qualifiedReturnType.replace('/', '.')); } } catch (IllegalArgumentException e) { } catch (JavaModelException e) { } return null; } public static IResource getSourceResource(IResource classFile) { try { if (isJavaProject(classFile) && classFile.getName().endsWith(CLASS_FILE_EXTENSION)) { IPath classFilePath = classFile.getFullPath(); String classFileName = null; IJavaProject project = getJavaProject(classFile); IPath defaultOutput = project.getOutputLocation(); if (defaultOutput.isPrefixOf(classFilePath)) { classFileName = classFilePath.removeFirstSegments(defaultOutput.segmentCount()).toString(); } else { for (IClasspathEntry entry : project.getRawClasspath()) { if (entry.getEntryKind() == IClasspathEntry.CPE_SOURCE) { IPath output = entry.getOutputLocation(); if (output != null) { if (classFilePath.isPrefixOf(output)) { classFileName = classFilePath.removeFirstSegments(output.segmentCount()) .toString(); } } } } } if (classFileName != null) { // Replace file extension String sourceFileName = classFileName.replace(".class", ".java"); for (IClasspathEntry entry : project.getRawClasspath()) { if (entry.getEntryKind() == IClasspathEntry.CPE_SOURCE) { IPath path = entry.getPath().append(sourceFileName).removeFirstSegments(1); IResource resource = project.getProject().findMember(path); if (resource != null) { return resource; } } } } } } catch (JavaModelException e) { } return null; } public static boolean isAjdtPresent() { try { Class.forName(AJDT_CLASS); return true; } catch (ClassNotFoundException e) { return false; } } /** * Returns true if given resource's project is a ADJT project. */ public static boolean isAjdtProject(IResource resource) { return SpringCoreUtils.hasNature(resource, AJDT_NATURE); } /** * Determines if the <code>resource</code> under question is the .classpath * file of a {@link IJavaProject}. */ public static boolean isClassPathFile(IResource resource) { String classPathFileName = resource.getProject().getFullPath().append(CLASSPATH_FILENAME).toString(); return resource.getFullPath().toString().equals(classPathFileName); } /** * Returns true if given resource's project is a Java project. */ public static boolean isJavaProject(IResource resource) { return SpringCoreUtils.hasNature(resource, JavaCore.NATURE_ID); } // public static boolean isTypeAjdtElement(IType type) { // if (IS_AJDT_PRESENT) { // return AjdtUtils.isTypeAjdtElement(type); // } // return false; // } public static boolean isTypeGroovyElement(IType type) { // TODO CD verify following check with Groovy Eclipse ICompilationUnit cu = type.getCompilationUnit(); if (cu != null && cu.getResource() != null) { return cu.getResource().getName().endsWith(GROOVY_FILE_EXTENSION); } else if (cu != null) { try { IResource resource = cu.getUnderlyingResource(); if (resource != null) { return resource.getName().endsWith(GROOVY_FILE_EXTENSION); } } catch (JavaModelException e) { // ignore } } return false; } public static String resolveClassName(String className, IType type) { if (className == null || type == null) { return className; } // replace binary $ inner class name syntax with . for source level className = className.replace('$', '.'); String dotClassName = new StringBuilder().append('.').append(className).toString(); IProject project = type.getJavaProject().getProject(); try { // Special handling for some well-know classes if (className.startsWith("java.lang") && getJavaType(project, className) != null) { return className; } // Check if the class is imported if (!type.isBinary()) { // Strip className to first segment to support // ReflectionUtils.MethodCallback int ix = className.lastIndexOf('.'); String firstClassNameSegment = className; if (ix > 0) { firstClassNameSegment = className.substring(0, ix); } // Iterate the imports for (IImportDeclaration importDeclaration : type.getCompilationUnit().getImports()) { String importName = importDeclaration.getElementName(); // Wildcard imports -> check if the package + className is a // valid type if (importDeclaration.isOnDemand()) { String newClassName = new StringBuilder(importName.substring(0, importName.length() - 1)) .append(className).toString(); if (getJavaType(project, newClassName) != null) { return newClassName; } } // Concrete import matching .className at the end -> check // if type exists else if (importName.endsWith(dotClassName) && getJavaType(project, importName) != null) { return importName; } // Check if className is multi segmented // (ReflectionUtils.MethodCallback) // -> check if the first segment else if (!className.equals(firstClassNameSegment)) { if (importName.endsWith(firstClassNameSegment)) { String newClassName = new StringBuilder( importName.substring(0, importName.lastIndexOf('.') + 1)).append(className) .toString(); if (getJavaType(project, newClassName) != null) { return newClassName; } } } } } // Check if the class is in the same package as the type String packageName = type.getPackageFragment().getElementName(); String newClassName = new StringBuilder(packageName).append(dotClassName).toString(); if (getJavaType(project, newClassName) != null) { return newClassName; } // Check if the className is sufficient (already fully-qualified) if (getJavaType(project, className) != null) { return className; } // Check if the class is coming from the java.lang newClassName = new StringBuilder("java.lang").append(dotClassName).toString(); if (getJavaType(project, newClassName) != null) { return newClassName; } // Fall back to full blown resolution String[][] fullInter = type.resolveType(className); if (fullInter != null && fullInter.length > 0) { return fullInter[0][0] + "." + fullInter[0][1]; } } catch (JavaModelException e) { StatusHandler.log( new Status(IStatus.ERROR, CorePlugin.PLUGIN_ID, "An error occurred resolving class name", e)); } return className; } public static String resolveClassNameBySignature(String className, IType type) { className = Signature.toString(className).replace('$', '.'); return resolveClassName(className, type); } public static void visitTypeAst(IType type, ASTVisitor visitor) { if (type != null && type.getCompilationUnit() != null) { ASTParser parser = ASTParser.newParser(AST.JLS3); parser.setSource(type.getCompilationUnit()); parser.setResolveBindings(true); ASTNode node = parser.createAST(new NullProgressMonitor()); node.accept(visitor); } } // private static boolean doesImplementWithJdt(IResource resource, IType // type, String className) { // IType interfaceType = getJavaType(resource.getProject(), className); // if (type != null && interfaceType != null) { // try { // IType[] subTypes = // SuperTypeHierarchyCache.getTypeHierarchy(interfaceType) // .getAllSubtypes(interfaceType); // if (subTypes != null) { // for (IType subType : subTypes) { // if (subType.equals(type)) { // return true; // } // } // } // } // catch (JavaModelException ex) { // StatusHandler.log(new Status(IStatus.ERROR, CorePlugin.PLUGIN_ID, // "An error occurred resolving subtypes", ex)); // } // } // return false; // } // private static String[] getParameterTypesAsStringArray(Class[] // parameterTypes) { // String[] parameterTypesAsString = new String[parameterTypes.length]; // for (int i = 0; i < parameterTypes.length; i++) { // parameterTypesAsString[i] = // ClassUtils.getQualifiedName(parameterTypes[i]); // } // return parameterTypesAsString; // } private static String[] getParameterTypesAsStringArray(IMethod method) { Set<String> typeParameterNames = new HashSet<String>(); try { for (ITypeParameter param : method.getDeclaringType().getTypeParameters()) { typeParameterNames.add(param.getElementName()); } for (ITypeParameter param : method.getTypeParameters()) { typeParameterNames.add(param.getElementName()); } } catch (JavaModelException e) { } String[] parameterTypesAsString = new String[method.getParameterTypes().length]; for (int i = 0; i < method.getParameterTypes().length; i++) { String parameterTypeString = Signature.getElementType(method.getParameterTypes()[i]); boolean isArray = !parameterTypeString.equals(method.getParameterTypes()[i]); String parameterType = resolveClassNameBySignature(parameterTypeString, method.getDeclaringType()); if (typeParameterNames.contains(parameterType)) { parameterTypesAsString[i] = Object.class.getName() + (isArray ? ARRAY_SUFFIX : ""); } else { parameterTypesAsString[i] = parameterType + (isArray ? ARRAY_SUFFIX : ""); } } return parameterTypesAsString; } // static class DefaultProjectClassLoaderSupport implements // IProjectClassLoaderSupport { // // private ClassLoader classLoader; // // private ClassLoader weavingClassLoader; // // public DefaultProjectClassLoaderSupport(IProject javaProject, ClassLoader // parentClassLoader) { // setupClassLoaders(javaProject, parentClassLoader); // } // // public void executeCallback(IProjectClassLoaderAwareCallback callback) // throws Throwable { // try { // activateWeavingClassLoader(); // callback.doWithActiveProjectClassLoader(); // } // finally { // recoverClassLoader(); // } // } // // public ClassLoader getProjectClassLoader() { // return this.weavingClassLoader; // } // // /** // * Activates the weaving class loader as thread context classloader. // * <p> // * Use {@link #recoverClassLoader()} to recover the original thread // * context classloader // */ // private void activateWeavingClassLoader() { // Thread.currentThread().setContextClassLoader(weavingClassLoader); // } // // private void recoverClassLoader() { // Thread.currentThread().setContextClassLoader(classLoader); // } // // private void setupClassLoaders(IProject project, ClassLoader // parentClassLoader) { // classLoader = Thread.currentThread().getContextClassLoader(); // weavingClassLoader = ProjectClassLoaderCache.getClassLoader(project, // parentClassLoader); // } // } }