import com.sun.mirror.type.ClassType; //导入依赖的package包/类
public static boolean isSubtype(TypeDeclaration d1, TypeDeclaration d2) {
    if (d1.equals(d2))
        return true;
    ClassDeclaration superClassDecl = null;
    if (d1 instanceof ClassDeclaration) {
        ClassType superClass = ((ClassDeclaration)d1).getSuperclass();
        if (superClass != null) {
            superClassDecl = superClass.getDeclaration();
            if (superClassDecl.equals(d2))
                return true;
        }
    }
    InterfaceDeclaration superIntf = null;
    for (InterfaceType interfaceType : d1.getSuperinterfaces()) {
        superIntf = interfaceType.getDeclaration();
        if (superIntf.equals(d2))
            return true;
    }
    if (superIntf != null && isSubtype(superIntf, d2)) {
        return true;
    } else if (superClassDecl != null && isSubtype(superClassDecl, d2)) {
        return true;
    }
    return false;
}
 

import com.sun.mirror.type.ClassType; //导入依赖的package包/类
private boolean generateExceptionBeans(MethodDeclaration method) {
    String beanPackage = packageName + PD_JAXWS_PACKAGE_PD;
    if (packageName.length() == 0)
        beanPackage = JAXWS_PACKAGE_PD;
    boolean beanGenerated = false;
    for (ReferenceType thrownType : method.getThrownTypes()) {
        ClassDeclaration typeDecl = ((ClassType)thrownType).getDeclaration();
        if (typeDecl == null){
            builder.onError(WebserviceapMessages.WEBSERVICEAP_COULD_NOT_FIND_TYPEDECL(thrownType.toString(), context.getRound()));
            return false;
        }
        boolean tmp = generateExceptionBean(typeDecl, beanPackage);
        beanGenerated = beanGenerated || tmp;
    }
    return beanGenerated;
}
 

import com.sun.mirror.type.ClassType; //导入依赖的package包/类
/**
 * Stores information about constructors annotated with {@link Constructor},
 * particularly with the {@link ConstructorParameter} annotated parameters
 * and their required imports. The {@link SPAnnotationProcessor} takes this
 * information and generates
 * {@link SPPersisterHelper#commitObject(ca.sqlpower.dao.PersistedSPObject, Multimap, List, ca.sqlpower.dao.helper.SPPersisterHelperFactory)}
 * and
 * {@link SPPersisterHelper#persistObject(SPObject, int, SPPersister, ca.sqlpower.dao.session.SessionPersisterSuperConverter)}
 * methods.
 * 
 * @param d
 *            The {@link ConstructorDeclaration} of the constructor to
 *            visit.
 */
public void visitConstructorDeclaration(ConstructorDeclaration d) {
	
	if (!constructorFound && d.getAnnotation(Constructor.class) != null 
			&& d.getSimpleName().equals(typeDecl.getSimpleName())) {
		
		for (ParameterDeclaration pd : d.getParameters()) {
			ConstructorParameter cp = pd.getAnnotation(ConstructorParameter.class);
			if (cp != null) {
				try {
					TypeMirror type = pd.getType();
					Class<?> c = SPAnnotationProcessorUtils.convertTypeMirrorToClass(type);
					
					ParameterType property = cp.parameterType();
					String name;
					
					if (property.equals(ParameterType.PROPERTY)) {
						name = cp.propertyName();
					} else {
						name = pd.getSimpleName();
					}

					if (type instanceof PrimitiveType) {
						constructorParameters.add(
								new ConstructorParameterObject(property, c, name));

					} else if (type instanceof ClassType || type instanceof InterfaceType) {
						constructorParameters.add(
								new ConstructorParameterObject(property, c, name));
						constructorImports.add(c.getName());
					}
				} catch (ClassNotFoundException e) {
					valid = false;
					e.printStackTrace();
				}
			}
		}
		constructorFound = true;
	}
}
 

import com.sun.mirror.type.ClassType; //导入依赖的package包/类
private static String computeOutputClass (ClassType classType)
{
	DeclaredType containingType = classType.getContainingType ();
	if (containingType == null)
		return classType.getDeclaration ().getQualifiedName ();
	throw new IllegalArgumentException ("The generated class cannot be a nested class.");
}
 

import com.sun.mirror.type.ClassType; //导入依赖的package包/类
public void visitClassDeclaration (ClassDeclaration classDeclaration)
{
	CookCCOption option = classDeclaration.getAnnotation (CookCCOption.class);
	if (option == null)
		return;
	m_option = option;

	m_doc.setMain (false);
	String inputClass = classDeclaration.getQualifiedName ();
	m_doc.setProperty (PROP_INPUT, inputClass);
	ClassType superClassType = classDeclaration.getSuperclass ();
	ClassDeclaration superClass = superClassType.getDeclaration ();
	m_doc.setProperty (PROP_OUTPUT, computeOutputClass (superClassType));

	if (superClass.getModifiers ().contains (Modifier.PUBLIC))
		m_doc.setProperty (PROP_PUBLIC, Boolean.TRUE);

	m_doc.setUnicode (option.unicode ());
	m_start = option.start ();

	String tokenClass = option.tokenClass ();
	if (tokenClass != null && (tokenClass = tokenClass.trim ()).length () != 0)
		m_doc.setProperty (PROP_TOKEN, tokenClass);

	// try to get the file header
	try
	{
		m_doc.addCode ("fileheader", generateFileHeader (FileHeaderScanner.getFileHeader (superClass.getPosition ().file ())));
	}
	catch (Exception ex)
	{
	}
	// try to get the class header
	m_doc.addCode ("classheader", generateClassHeader (superClass.getDocComment ()));

	m_parent.addDocument (classDeclaration.getQualifiedName (), m_doc);
}
 

import com.sun.mirror.type.ClassType; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
public ClassType getSuperclass() {
    //  java.lang.Object has no superclass
    if (sym == env.symtab.objectType.tsym) {
        return null;
    }
    Type t = env.jctypes.supertype(sym.type);
    return (ClassType) env.typeMaker.getType(t);
}
 

import com.sun.mirror.type.ClassType; //导入依赖的package包/类
protected JDefinedClass getCMClass(String className, com.sun.codemodel.internal.ClassType type) {
    JDefinedClass cls;
    try {
        cls = cm._class(className, type);
    } catch (com.sun.codemodel.internal.JClassAlreadyExistsException e){
        cls = cm._getClass(className);
    }
    return cls;
}
 

import com.sun.mirror.type.ClassType; //导入依赖的package包/类
public TypeDeclaration getSuperClass(TypeDeclaration t) {
    if (t instanceof ClassDeclaration) {
        ClassDeclaration c = (ClassDeclaration) t;
        ClassType sup = c.getSuperclass();
        if(sup!=null)
            return sup.getDeclaration();
        else
            return null;
    }
    return env.getTypeDeclaration(Object.class.getName());
}
 

import com.sun.mirror.type.ClassType; //导入依赖的package包/类
public TypeMirror onClassType(ClassType type, TypeDeclaration sup) {
    TypeMirror r = onDeclaredType(type,sup);
    if(r!=null)     return r;

    // otherwise recursively apply super class and base types
    if(type.getSuperclass()!=null) {
        r = onClassType(type.getSuperclass(),sup);
        if(r!=null)     return r;
    }

    return null;
}
 

import com.sun.mirror.type.ClassType; //导入依赖的package包/类
/**
 * Returns the class type directly extended by this class.
 * The only class with no superclass is <tt>java.lang.Object</tt>,
 * for which this method returns null.
 *
 * @return the class type directly extended by this class, or null
 * if there is none
 */
ClassType getSuperclass();
 

import com.sun.mirror.type.ClassType; //导入依赖的package包/类
protected abstract T onClassType(ClassType type, P param);