import japa.parser.ast.PackageDeclaration; //导入依赖的package包/类
public final String getCompilationUnitContents(
        final ClassOrInterfaceTypeDetails cid) {
    Validate.notNull(cid, "Class or interface type details are required");
    // Create a compilation unit to store the type to be created
    final CompilationUnit compilationUnit = new CompilationUnit();

    // NB: this import list is replaced at the end of this method by a
    // sorted version
    compilationUnit.setImports(new ArrayList<ImportDeclaration>());

    if (!cid.getName().isDefaultPackage()) {
        compilationUnit.setPackage(new PackageDeclaration(ASTHelper
                .createNameExpr(cid.getName().getPackage()
                        .getFullyQualifiedPackageName())));
    }

    // Add the class of interface declaration to the compilation unit
    final List<TypeDeclaration> types = new ArrayList<TypeDeclaration>();
    compilationUnit.setTypes(types);

    updateOutput(compilationUnit, null, cid, null);

    return compilationUnit.toString();
}
 

import japa.parser.ast.PackageDeclaration; //导入依赖的package包/类
@Override
public void visit(PackageDeclaration declaration, Object arg)
{	String pack = declaration.getName().toString();

	// on met à jour le package de l'API courante
	apiPackage = AiPackageTools.getApiPackage(pack);

	// on met à jour le package du pack courant
	packPackage = AiPackageTools.getPackPackage(pack);
	
	// on met à jour le package de l'agent courant
	agentPackage = AiPackageTools.getAgentPackage(pack,true);
	
	// on met à jour la classe mère de l'agent courant
	agentClass = AiPackageTools.getAgentPackage(pack,false) + ClassTools.CLASS_SEPARATOR + "AiMain";
}
 

import japa.parser.ast.PackageDeclaration; //导入依赖的package包/类
public Node visit(CompilationUnit n, A arg) {
    if (n.getPackage() != null) {
        n.setPackage((PackageDeclaration) n.getPackage().accept(this, arg));
    }
    List<ImportDeclaration> imports = n.getImports();
    if (imports != null) {
        for (int i = 0; i < imports.size(); i++) {
            imports.set(i, (ImportDeclaration) imports.get(i).accept(this, arg));
        }
        removeNulls(imports);
    }
    List<TypeDeclaration> types = n.getTypes();
    if (types != null) {
        for (int i = 0; i < types.size(); i++) {
            types.set(i, (TypeDeclaration) types.get(i).accept(this, arg));
        }
        removeNulls(types);
    }
    return n;
}
 

import japa.parser.ast.PackageDeclaration; //导入依赖的package包/类
private CompilationUnit createNewCompilationUnit(String aPackageName, String aMainTypeName) {
    CompilationUnit theUnit = new CompilationUnit();
    if (!StringUtils.isEmpty(aPackageName)) {
        theUnit.setPackage(new PackageDeclaration(ASTHelper.createNameExpr(aPackageName)));
    }
    List<ImportDeclaration> theImports = new ArrayList<>();
    theImports.add(new ImportDeclaration(ASTHelper.createNameExpr("java.util"), false, true));
    theImports.add(new ImportDeclaration(ASTHelper.createNameExpr("javax.persistence"), false, true));
    theImports.add(new ImportDeclaration(ASTHelper.createNameExpr("org.openxava.annotations"), false, true));
    theUnit.setImports(theImports);
    ClassOrInterfaceDeclaration theType = new ClassOrInterfaceDeclaration(ModifierSet.PUBLIC, false, aMainTypeName);
    ASTHelper.addTypeDeclaration(theUnit, theType);
    return theUnit;
}
 

import japa.parser.ast.PackageDeclaration; //导入依赖的package包/类
public static void buildUnit() {
    CompilationUnit compUnit = new CompilationUnit();
    
    compUnit.setPackage(new PackageDeclaration(ASTHelper
                                               .createNameExpr("compiladores.aula")));
    
    // create the type declaration
    ClassOrInterfaceDeclaration type = new ClassOrInterfaceDeclaration(
                                                                       ModifierSet.PUBLIC, false, "AulaJavaParser");
    ASTHelper.addTypeDeclaration(compUnit, type);
    
    // create a method
    MethodDeclaration method = new MethodDeclaration(ModifierSet.PUBLIC,
                                                     ASTHelper.VOID_TYPE, "main");
    method.setModifiers(ModifierSet.addModifier(method.getModifiers(),
                                                ModifierSet.STATIC));
    ASTHelper.addMember(type, method);
    
    // add a parameter to the method
    Parameter param = ASTHelper.createParameter(
                                                ASTHelper.createReferenceType("String", 0), "args");
    param.setVarArgs(true); //makes the parameter a ",,," array
    ASTHelper.addParameter(method, param);
    
    // add a body to the method
    BlockStmt block = new BlockStmt();
    method.setBody(block);
    
    // add a statement do the method body
    NameExpr clazz = new NameExpr("System");
    FieldAccessExpr field = new FieldAccessExpr(clazz, "out");
    MethodCallExpr call = new MethodCallExpr(field, "println");
    ASTHelper.addArgument(call, new StringLiteralExpr("Hello World!"));
    ASTHelper.addStmt(block, call);
    
    System.out.println(compUnit.toString());
}
 

import japa.parser.ast.PackageDeclaration; //导入依赖的package包/类
public R visit(PackageDeclaration n, A arg) {
    if (n.getAnnotations() != null) {
        for (AnnotationExpr a : n.getAnnotations()) {
            a.accept(this, arg);
        }
    }
    n.getName().accept(this, arg);
    return null;
}
 

import japa.parser.ast.PackageDeclaration; //导入依赖的package包/类
public Boolean visit(PackageDeclaration n1, Node arg) {
    PackageDeclaration n2 = (PackageDeclaration) arg;

    if (!nodeEquals(n1.getName(), n2.getName())) {
        return Boolean.FALSE;
    }

    if (!nodesEquals(n1.getAnnotations(), n2.getAnnotations())) {
        return Boolean.FALSE;
    }

    return Boolean.TRUE;
}
 

import japa.parser.ast.PackageDeclaration; //导入依赖的package包/类
public void visit(PackageDeclaration n, Object arg) {
    printAnnotations(n.getAnnotations(), arg);
    printer.print("package ");
    n.getName().accept(this, arg);
    printer.printLn(";");
    printer.printLn();
}
 

import japa.parser.ast.PackageDeclaration; //导入依赖的package包/类
public void visit(PackageDeclaration n, A arg) {
    if (n.getAnnotations() != null) {
        for (AnnotationExpr a : n.getAnnotations()) {
            a.accept(this, arg);
        }
    }
    n.getName().accept(this, arg);
}
 

import japa.parser.ast.PackageDeclaration; //导入依赖的package包/类
@Test
public void tesCompilationUnitNotEqual() throws Exception {
    String source = Helper.readClass("./test", DumperTestClass.class);
    CompilationUnit cu1 = Helper.parserString(source);
    CompilationUnit cu2 = Helper.parserString(source);

    cu2.setPackage(new PackageDeclaration(new NameExpr("diff_package")));
    assertNotEqualsAndHashCode(cu1, cu2);
}
 

import japa.parser.ast.PackageDeclaration; //导入依赖的package包/类
@Override
public void visit(PackageDeclaration n, Generator arg) {
    throw new TransformException("don't know how to linearize");
}
 

import japa.parser.ast.PackageDeclaration; //导入依赖的package包/类
@Override
public Boolean visit(PackageDeclaration n, Void arg) {
    return false;
}
 

import japa.parser.ast.PackageDeclaration; //导入依赖的package包/类
@Override
public void visit(PackageDeclaration n, Scope arg) {
    super.visit(n, arg);
    n.setData(arg);
}
 

import japa.parser.ast.PackageDeclaration; //导入依赖的package包/类
@Override
public void visit(PackageDeclaration n, Object arg) {
    doTest(source, n);
    super.visit(n, arg);
}
 

import japa.parser.ast.PackageDeclaration; //导入依赖的package包/类
private static CompilationUnit createInitialCu(String projPackage) {
	CompilationUnit newCu = new CompilationUnit();
	newCu.setPackage(new PackageDeclaration(new NameExpr(projPackage)));
	return newCu;
}
 

import japa.parser.ast.PackageDeclaration; //导入依赖的package包/类
@Override
public void visitPre(PackageDeclaration n, A arg) {
    
}
 

import japa.parser.ast.PackageDeclaration; //导入依赖的package包/类
@Override
public void visitPost(PackageDeclaration n, A arg) {
    
}
 

import japa.parser.ast.PackageDeclaration; //导入依赖的package包/类
void visitPre(PackageDeclaration n, A arg); 

import japa.parser.ast.PackageDeclaration; //导入依赖的package包/类
void visitPost(PackageDeclaration n, A arg); 

import japa.parser.ast.PackageDeclaration; //导入依赖的package包/类
public R visit(PackageDeclaration n, A arg);