| /******************************************************************************* |
| * Copyright (c) 2010 Shane Clarke. |
| * 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: |
| * Shane Clarke - initial API and implementation |
| *******************************************************************************/ |
| package org.eclipse.jst.ws.internal.jaxws.core.annotations.validation; |
| |
| import java.util.ArrayList; |
| import java.util.Collection; |
| import java.util.HashSet; |
| import java.util.List; |
| import java.util.Set; |
| |
| import javax.jws.WebService; |
| import javax.xml.bind.annotation.XmlType; |
| |
| import org.eclipse.jdt.apt.core.env.EclipseAnnotationProcessorEnvironment; |
| import org.eclipse.jdt.core.Flags; |
| import org.eclipse.jdt.core.IJavaProject; |
| import org.eclipse.jdt.core.IType; |
| import org.eclipse.jdt.core.ITypeHierarchy; |
| import org.eclipse.jdt.core.JavaModelException; |
| import org.eclipse.jst.ws.annotations.core.processor.AbstractAnnotationProcessor; |
| import org.eclipse.jst.ws.annotations.core.utils.AnnotationUtils; |
| import org.eclipse.jst.ws.internal.jaxws.core.JAXWSCoreMessages; |
| import org.eclipse.jst.ws.internal.jaxws.core.JAXWSCorePlugin; |
| |
| import com.sun.mirror.declaration.AnnotationTypeDeclaration; |
| import com.sun.mirror.declaration.ClassDeclaration; |
| import com.sun.mirror.declaration.Declaration; |
| import com.sun.mirror.declaration.InterfaceDeclaration; |
| import com.sun.mirror.declaration.MethodDeclaration; |
| import com.sun.mirror.declaration.Modifier; |
| import com.sun.mirror.declaration.ParameterDeclaration; |
| import com.sun.mirror.declaration.TypeDeclaration; |
| import com.sun.mirror.type.ArrayType; |
| import com.sun.mirror.type.ClassType; |
| import com.sun.mirror.type.InterfaceType; |
| import com.sun.mirror.type.TypeMirror; |
| |
| public class WebServiceParametersReturnTypesRule extends AbstractAnnotationProcessor { |
| |
| private static final Set<String> JAVA_TYPES = new HashSet<String>(); |
| |
| private static final Set<String> ALLOWED_IN_MULTIPLE_INHERITANCE = new HashSet<String>(); |
| |
| static { |
| JAVA_TYPES.add("java.util.Calendar"); //$NON-NLS-1$ |
| JAVA_TYPES.add("java.util.Date"); //$NON-NLS-1$ |
| JAVA_TYPES.add("java.util.GregorianCalendar"); //$NON-NLS-1$ |
| JAVA_TYPES.add("javax.xml.datatype.XMLGregorianCalendar"); //$NON-NLS-1$ |
| |
| JAVA_TYPES.add("java.util.ArrayList"); //$NON-NLS-1$ |
| JAVA_TYPES.add("java.util.HashSet"); //$NON-NLS-1$ |
| JAVA_TYPES.add("java.util.LinkedList"); //$NON-NLS-1$ |
| JAVA_TYPES.add("java.util.List"); //$NON-NLS-1$ |
| JAVA_TYPES.add("java.util.Stack"); //$NON-NLS-1$ |
| JAVA_TYPES.add("java.util.Vector"); //$NON-NLS-1$ |
| |
| JAVA_TYPES.add("java.math.BigDecimal"); //$NON-NLS-1$ |
| JAVA_TYPES.add("java.math.BigInteger"); //$NON-NLS-1$ |
| JAVA_TYPES.add("java.lang.Object"); //$NON-NLS-1$ |
| JAVA_TYPES.add("javax.xml.namespace.QName"); //$NON-NLS-1$ |
| JAVA_TYPES.add("java.util.UUID"); //$NON-NLS-1$ |
| JAVA_TYPES.add("java.net.URI"); //$NON-NLS-1$ |
| JAVA_TYPES.add("java.awt.Image"); //$NON-NLS-1$ |
| JAVA_TYPES.add("javax.xml.datatype.Duration"); //$NON-NLS-1$ |
| JAVA_TYPES.add("javax.xml.transform.Source"); //$NON-NLS-1$ |
| JAVA_TYPES.add("javax.activation.DataHandler"); //$NON-NLS-1$ |
| |
| JAVA_TYPES.add("java.lang.String"); //$NON-NLS-1$ |
| JAVA_TYPES.add("java.lang.Boolean"); //$NON-NLS-1$ |
| JAVA_TYPES.add("java.lang.Integer"); //$NON-NLS-1$ |
| JAVA_TYPES.add("java.lang.Character"); //$NON-NLS-1$ |
| JAVA_TYPES.add("java.lang.Float"); //$NON-NLS-1$ |
| JAVA_TYPES.add("java.lang.Byte"); //$NON-NLS-1$ |
| JAVA_TYPES.add("java.lang.Double"); //$NON-NLS-1$ |
| JAVA_TYPES.add("java.lang.Long"); //$NON-NLS-1$ |
| JAVA_TYPES.add("java.lang.Short"); //$NON-NLS-1$ |
| JAVA_TYPES.add("java.lang.Void"); //$NON-NLS-1$ |
| |
| JAVA_TYPES.add("java.rmi.RemoteException"); //$NON-NLS-1$ |
| |
| JAVA_TYPES.add("java.io.Serializable"); //$NON-NLS-1$ |
| JAVA_TYPES.add("java.lang.Cloneable"); //$NON-NLS-1$ |
| JAVA_TYPES.add("java.lang.Comparable"); //$NON-NLS-1$ |
| |
| JAVA_TYPES.add("java.util.Map"); //$NON-NLS-1$ |
| JAVA_TYPES.add("java.util.HashMap"); //$NON-NLS-1$ |
| JAVA_TYPES.add("java.util.Hashtable"); //$NON-NLS-1$ |
| JAVA_TYPES.add("java.util.Collection"); //$NON-NLS-1$ |
| |
| JAVA_TYPES.add("java.lang.Exception"); //$NON-NLS-1$ |
| JAVA_TYPES.add("java.lang.Throwable"); //$NON-NLS-1$ |
| JAVA_TYPES.add("java.lang.StackTraceElement"); //$NON-NLS-1$ |
| |
| ALLOWED_IN_MULTIPLE_INHERITANCE.add("java.lang.Cloneable"); // $NON-NLS$ |
| ALLOWED_IN_MULTIPLE_INHERITANCE.add("java.lang.Comparable"); // $NON-NLS$ |
| ALLOWED_IN_MULTIPLE_INHERITANCE.add("java.io.Serializable"); // $NON-NLS$ |
| } |
| |
| private static final String REMOTE_OBJECT = "java.rmi.Remote"; |
| |
| @Override |
| public void process() { |
| AnnotationTypeDeclaration webServiceDeclaration = (AnnotationTypeDeclaration) environment |
| .getTypeDeclaration(WebService.class.getName()); |
| |
| Collection<Declaration> annotatedTypes = environment.getDeclarationsAnnotatedWith(webServiceDeclaration); |
| |
| for (Declaration declaration : annotatedTypes) { |
| if (declaration instanceof InterfaceDeclaration) { |
| validateMethodParametersAndReturnTypes((InterfaceDeclaration) declaration); |
| } |
| } |
| } |
| |
| private void validateMethodParametersAndReturnTypes(InterfaceDeclaration interfaceDeclaration) { |
| Collection<? extends MethodDeclaration> methods = interfaceDeclaration.getMethods(); |
| for (MethodDeclaration methodDeclaration : methods) { |
| TypeMirror returnType = methodDeclaration.getReturnType(); |
| validateTypeMirror(returnType, methodDeclaration); |
| Collection<ParameterDeclaration> parameters = methodDeclaration.getParameters(); |
| for (ParameterDeclaration parameterDeclaration : parameters) { |
| validateTypeMirror(parameterDeclaration.getType(), methodDeclaration); |
| } |
| } |
| } |
| |
| private void validateTypeMirror(TypeMirror returnType, MethodDeclaration methodDeclaration) { |
| if (returnType instanceof ArrayType) { |
| ArrayType arrayType = (ArrayType) returnType; |
| |
| TypeMirror componentType = arrayType.getComponentType(); |
| if (componentType instanceof ClassDeclaration) { |
| ClassDeclaration classDeclaration = (ClassDeclaration) componentType; |
| checkClassRestriction(classDeclaration, methodDeclaration); |
| } |
| } |
| |
| if (returnType instanceof InterfaceType) { |
| InterfaceType interfaceType = (InterfaceType) returnType; |
| Collection<TypeMirror> typeArguments = interfaceType.getActualTypeArguments(); |
| if (typeArguments.size() > 0) { |
| for (TypeMirror typeMirror : typeArguments) { |
| if (typeMirror instanceof ClassDeclaration) { |
| ClassDeclaration classDeclaration = (ClassDeclaration) typeMirror; |
| checkClassRestriction(classDeclaration, methodDeclaration); |
| } |
| if (typeMirror instanceof InterfaceDeclaration) { |
| checkInterface((InterfaceDeclaration) typeMirror, methodDeclaration); |
| } |
| } |
| } |
| checkInterface(interfaceType.getDeclaration(), methodDeclaration); |
| |
| } |
| |
| if (returnType instanceof ClassType) { |
| ClassType classType = (ClassType) returnType; |
| Collection<TypeMirror> typeArguments = classType.getActualTypeArguments(); |
| if (typeArguments.size() > 0) { |
| for (TypeMirror typeMirror : typeArguments) { |
| if (typeMirror instanceof ClassDeclaration) { |
| ClassDeclaration classDeclaration = (ClassDeclaration) typeMirror; |
| checkClassRestriction(classDeclaration, methodDeclaration); |
| } |
| } |
| } else { |
| if (classType.getDeclaration() != null) { |
| checkClassRestriction(classType.getDeclaration(), methodDeclaration); |
| } |
| } |
| } |
| |
| } |
| |
| private void checkClassRestriction(ClassDeclaration classDeclaration, MethodDeclaration methodDeclaration) { |
| checkInnerPublicStaticTypes(classDeclaration, methodDeclaration); |
| checkIfRemoteObject(classDeclaration, methodDeclaration); |
| checkAbstactType(classDeclaration, methodDeclaration); |
| checkMultipleInheritance(classDeclaration, methodDeclaration); |
| } |
| |
| private void checkInnerPublicStaticTypes(ClassDeclaration classDeclaration, MethodDeclaration methodDeclaration) { |
| if (hasInnerNonPublicStaticTypes(classDeclaration)) { |
| printError(methodDeclaration.getPosition(), JAXWSCoreMessages.bind( |
| JAXWSCoreMessages.HAS_INADMISSIBLE_INNER_TYPES, classDeclaration.getQualifiedName())); |
| } |
| } |
| |
| private boolean hasInnerNonPublicStaticTypes(ClassDeclaration classDeclaration) { |
| if (isJavaType(classDeclaration.getQualifiedName()) && JAVA_TYPES.contains(classDeclaration.getQualifiedName())) { |
| return false; |
| } |
| Collection<TypeDeclaration> nestedTypes = classDeclaration.getNestedTypes(); |
| for (TypeDeclaration typeDeclaration : nestedTypes) { |
| if (!typeDeclaration.getModifiers().contains(Modifier.PUBLIC) |
| || !typeDeclaration.getModifiers().contains(Modifier.STATIC)) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| private void checkInterface(InterfaceDeclaration interfaceDeclaration, MethodDeclaration methodDeclaration) { |
| if (!isSuitableInterface(interfaceDeclaration)) { |
| printError(methodDeclaration.getPosition(), JAXWSCoreMessages.bind( |
| JAXWSCoreMessages.INTERFACES_NOT_SUPPORTED, interfaceDeclaration.getQualifiedName())); |
| } |
| } |
| |
| private boolean isSuitableInterface(InterfaceDeclaration interfaceDeclaration) { |
| return isJavaType(interfaceDeclaration.getQualifiedName()) && JAVA_TYPES.contains(interfaceDeclaration.getQualifiedName()) |
| || isXMLType(interfaceDeclaration); |
| } |
| |
| private boolean isXMLType(InterfaceDeclaration interfaceDeclaration) { |
| return AnnotationUtils.getAnnotation(interfaceDeclaration, XmlType.class) != null; |
| } |
| |
| private void checkIfRemoteObject(ClassDeclaration classDeclaration, MethodDeclaration methodDeclaration) { |
| if (isRemoteObject(classDeclaration)) { |
| printError(methodDeclaration.getPosition(), JAXWSCoreMessages.bind( |
| JAXWSCoreMessages.IS_REMOTE_OBJECT, classDeclaration.getQualifiedName())); |
| } |
| } |
| |
| private boolean isRemoteObject(ClassDeclaration classDeclaration) { |
| Collection<InterfaceType> superInterfaces = classDeclaration.getSuperinterfaces(); |
| for (InterfaceType interfaceType : superInterfaces) { |
| |
| if (interfaceType.getDeclaration() != null && interfaceType.getDeclaration().getQualifiedName().equals(REMOTE_OBJECT)) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| private void checkAbstactType(ClassDeclaration classDeclaration, MethodDeclaration methodDeclaration) { |
| if (classDeclaration.getModifiers().contains(Modifier.ABSTRACT)) { |
| if (environment instanceof EclipseAnnotationProcessorEnvironment) { |
| EclipseAnnotationProcessorEnvironment eclipseEnvironment = (EclipseAnnotationProcessorEnvironment) environment; |
| IJavaProject javaProject = eclipseEnvironment.getJavaProject(); |
| try { |
| IType type = javaProject.findType(classDeclaration.getQualifiedName()); |
| ITypeHierarchy hierarchy = type.newTypeHierarchy(null); |
| IType[] subTypes = hierarchy.getAllSubtypes(type); |
| if (subTypes.length > 0) { |
| for (IType subType : subTypes) { |
| if (!Flags.isAbstract(subType.getFlags())) { |
| TypeDeclaration typeDeclaration = environment.getTypeDeclaration(subType.getFullyQualifiedName()); |
| if (typeDeclaration instanceof ClassDeclaration) { |
| ClassDeclaration subTypeDeclaration = (ClassDeclaration) typeDeclaration; |
| if (isRemoteObject(subTypeDeclaration) || hasInnerNonPublicStaticTypes(subTypeDeclaration) |
| || implementsMultipleInterfaces(subTypeDeclaration) |
| || implementsClassAndInterface(subTypeDeclaration)) { |
| printError(methodDeclaration.getPosition(), JAXWSCoreMessages.bind( |
| JAXWSCoreMessages.ABSTRACT_CLASS_NOT_IMPLEMENTED, |
| classDeclaration.getQualifiedName())); |
| } |
| } |
| } |
| } |
| } else { |
| printError(methodDeclaration.getPosition(), JAXWSCoreMessages.bind( |
| JAXWSCoreMessages.ABSTRACT_CLASS_NOT_IMPLEMENTED, |
| classDeclaration.getQualifiedName())); |
| } |
| } catch (JavaModelException jme) { |
| JAXWSCorePlugin.log(jme.getStatus()); |
| } |
| } |
| } |
| } |
| |
| private boolean implementsMultipleInterfaces(ClassDeclaration classDeclaration) { |
| if (hasSuperClass(classDeclaration)) { |
| return countAllowedInterfaces(classDeclaration.getSuperinterfaces()) > 1; |
| } |
| return false; |
| } |
| |
| private boolean implementsClassAndInterface(ClassDeclaration classDeclaration) { |
| if (!hasSuperClass(classDeclaration)) { |
| return countAllowedInterfaces(classDeclaration.getSuperinterfaces()) > 0; |
| } |
| return false; |
| } |
| |
| private boolean hasSuperClass(ClassDeclaration classDeclaration) { |
| ClassType superClass = classDeclaration.getSuperclass(); |
| if (superClass.getDeclaration() != null) { |
| String qualifiedName = superClass.getDeclaration().getQualifiedName(); |
| return qualifiedName.equals(Object.class.getName()) || qualifiedName.equals(Exception.class.getName()); |
| } |
| return false; |
| } |
| |
| private void checkMultipleInheritance(ClassDeclaration classDeclaration, MethodDeclaration methodDeclaration) { |
| if (implementsMultipleInterfaces(classDeclaration)) { |
| List<String> interfaceNames = getAllowedInterfaceNames(classDeclaration.getSuperinterfaces()); |
| printError(methodDeclaration.getPosition(), JAXWSCoreMessages.bind( |
| JAXWSCoreMessages.IMPLEMENTS_MULTIPLE_INTERFACES, |
| new Object [] { classDeclaration.getQualifiedName(), interfaceNames.get(0), interfaceNames.get(1) })); |
| } |
| if (implementsClassAndInterface(classDeclaration)) { |
| List<String> interfaceNames = getAllowedInterfaceNames(classDeclaration.getSuperinterfaces()); |
| printError(methodDeclaration.getPosition(), JAXWSCoreMessages.bind( |
| JAXWSCoreMessages.INHERITANCE_AND_IMPLEMENTATION, |
| new Object[] {classDeclaration.getQualifiedName(), |
| classDeclaration.getSuperclass().getDeclaration().getQualifiedName(), |
| interfaceNames.get(0)} )); |
| } |
| } |
| |
| private List<String> getAllowedInterfaceNames(Collection<InterfaceType> superInterfaces) { |
| List<String> interfaceNames = new ArrayList<String>(); |
| for (InterfaceType interfaceType : superInterfaces) { |
| if (interfaceType.getDeclaration() != null) { |
| InterfaceDeclaration superInterface = interfaceType.getDeclaration(); |
| if (!ALLOWED_IN_MULTIPLE_INHERITANCE.contains(superInterface.getQualifiedName())) { |
| interfaceNames.add(superInterface.getQualifiedName()); |
| } |
| } |
| } |
| return interfaceNames; |
| } |
| |
| private int countAllowedInterfaces(Collection<InterfaceType> superInterfaces) { |
| int count = 0; |
| for (InterfaceType interfaceType : superInterfaces) { |
| if (interfaceType.getDeclaration() != null) { |
| InterfaceDeclaration superInterface = interfaceType.getDeclaration(); |
| if (!ALLOWED_IN_MULTIPLE_INHERITANCE.contains(superInterface.getQualifiedName())) { |
| count++; |
| } |
| } |
| } |
| return count; |
| } |
| |
| private boolean isJavaType(String typeName) { |
| return typeName.startsWith("java.") || typeName.startsWith("javax."); //$NON-NLS-1$ //$NON-NLS-2$ |
| } |
| |
| } |
