import japa.parser.ast.stmt.BlockStmt; //导入依赖的package包/类
@Override
public Boolean visit(BlockStmt n, Void arg) {
    boolean needsProcessing = false;

    if (n.getStmts() != null) {
        for (Statement s : n.getStmts()) {
            needsProcessing = s.accept(this, arg) || needsProcessing;
        }
    }
    if (needsProcessing) {
        NodeAnnotation nodeAnnotation = new NodeAnnotation(true);
        n.setData(nodeAnnotation);
    }
    return needsProcessing;

}
 

import japa.parser.ast.stmt.BlockStmt; //导入依赖的package包/类
private static AssignExpr findRootAssignExpr(BlockStmt body) {
    if (body.getStmts() != null) {
        for (Statement s : body.getStmts()) {
            if (s instanceof ExpressionStmt) {
                ExpressionStmt est = (ExpressionStmt) s;
                if (est.getExpression() instanceof AssignExpr) {
                    AssignExpr ass = (AssignExpr) est.getExpression();
                    if (ass.getTarget() instanceof FieldAccessExpr) {
                        FieldAccessExpr fae = (FieldAccessExpr) ass.getTarget();
                        if ("root".equals(fae.getField())) {
                            return ass;
                        }
                    }
                }
            }
        }
    }
    return null;
}
 

import japa.parser.ast.stmt.BlockStmt; //导入依赖的package包/类
private void addAttachSkeleton() {
	List<Parameter> params = Collections.emptyList();
	MethodDeclaration method = new MethodDeclaration(
			ModifierSet.PUBLIC, new VoidType(), "attach", params);
	AnnotationExpr override = new MarkerAnnotationExpr(new NameExpr("Override"));
	method.setAnnotations(Collections.singletonList(override));
	
	BlockStmt block = new BlockStmt();
	Expression e = new MethodCallExpr(new SuperExpr(), "attach");
	List<Statement> sts = Collections.singletonList((Statement)new ExpressionStmt(e));
	block.setStmts(sts);
	method.setBody(block);
	
	if (getType().getMembers()==null) {
		getType().setMembers(new LinkedList<BodyDeclaration>());
	}
	getType().getMembers().add(method);
}
 

import japa.parser.ast.stmt.BlockStmt; //导入依赖的package包/类
@SuppressWarnings("unused")
private void addOnBecomingVisibleMethod() {
	List<Parameter> params = Collections.emptyList();
	MethodDeclaration method = new MethodDeclaration(
			ModifierSet.PUBLIC, new VoidType(), "onBecomingVisible", params);
	AnnotationExpr override = new MarkerAnnotationExpr(new NameExpr("Override"));
	method.setAnnotations(Collections.singletonList(override));
	
	BlockStmt block = new BlockStmt();
	Expression e = new MethodCallExpr(new SuperExpr(), "onBecomingVisible");
	List<Statement> sts = Collections.singletonList((Statement)new ExpressionStmt(e));
	block.setStmts(sts);
	method.setBody(block);
	
	if (getType().getMembers()==null) {
		getType().setMembers(new LinkedList<BodyDeclaration>());
	}
	getType().getMembers().add(method);
}
 

import japa.parser.ast.stmt.BlockStmt; //导入依赖的package包/类
private MethodDeclaration addClaraHandler(String id, String className) {
	ensureImport(className);
	String shortName = className.substring(className.lastIndexOf(".")+1);
	String handlerName = generateHandlerNameFor(id, shortName);
	
	Parameter p = new Parameter(new ClassOrInterfaceType(shortName), new VariableDeclaratorId("event"));
	MethodDeclaration handler = new MethodDeclaration(
			ModifierSet.PUBLIC, new VoidType(), handlerName, Collections.singletonList(p));
	handler.setBody(new BlockStmt());
	handler.setAnnotations(createClaraHandlerAnnotations(id));
	
	addNotification(handler, shortName+" on "+id);		
	
	addMember(handler);
	return handler;
}
 

import japa.parser.ast.stmt.BlockStmt; //导入依赖的package包/类
@Override
  public void visit(ConstructorDeclaration n, Object arg)
  {	String prevMethod = currentMethod;
  	currentMethod = n.getName();
  	indentLevel++;
  	
  	if (n.getJavaDoc() != null)
  	{	n.getJavaDoc().accept(this, arg);
      }
      if(n.getAnnotations() != null)
      {	for (AnnotationExpr a : n.getAnnotations())
      	{	a.accept(this, arg);
          }
      }
      if(n.getTypeParameters() != null)
      {	for (TypeParameter t : n.getTypeParameters())
      	{	t.accept(this, arg);
          }
      }
      if(n.getParameters() != null)
      {	for (Parameter p : n.getParameters())
      	{	p.accept(this, arg);
          }
      }
      if(n.getThrows() != null)
      {	for (NameExpr name : n.getThrows())
      	{	name.accept(this, arg);
          }
      }
      BlockStmt block = n.getBlock();
      for(int i=0;i<indentLevel;i++)
	System.out.print("..");
System.out.println("Analyse du constructeur "+currentMethod);
  	if(checkConstructor)
  		checkBlock(block);
      block.accept(this, arg);
      
      currentMethod = prevMethod;
  	indentLevel--;
 }
 

import japa.parser.ast.stmt.BlockStmt; //导入依赖的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.stmt.BlockStmt; //导入依赖的package包/类
@Override
public void visit(BlockStmt n, Generator s) {
    if (n.getStmts() == null) return;

    // Either add statements from the block into the transformer state, or process them because
    // we have yields in them.
    for (Statement stmt : n.getStmts()) {
        if (stmt.getData() instanceof NodeAnnotation && ((NodeAnnotation) stmt.getData()).needsProcessing) {
            stmt.accept(this, s);
        } else {
            s.addStatement(stmt);
        }
    }

}
 

import japa.parser.ast.stmt.BlockStmt; //导入依赖的package包/类
@Override
public Node visit(DoStmt n, Void arg) {
    super.visit(n, arg);

    // Reword the loop.
    List<Statement> stmts = new ArrayList<Statement>();
    stmts.add(n.getBody());
    stmts.add(makeLoopCondition(n.getCondition()));
    BlockStmt b = new BlockStmt(stmts);
    return makeLoopStmt(b);
}
 

import japa.parser.ast.stmt.BlockStmt; //导入依赖的package包/类
/**
 * Generate an immediate jump.
 */
public static Statement generateJump(int state) {
    List<Statement> stmts = new ArrayList<Statement>();
    stmts.add(generateDeferredJump(state));
    stmts.add(new BreakStmt(null));
    return new BlockStmt(stmts);
}
 

import japa.parser.ast.stmt.BlockStmt; //导入依赖的package包/类
@Override
public Node visit(BlockStmt n, Map<String, TypedVariableDeclarator> arg) {
    this.enter();
    Node r = super.visit(n, arg);
    this.exit();
    return r;
}
 

import japa.parser.ast.stmt.BlockStmt; //导入依赖的package包/类
@Override
public void visit(BlockStmt n, Scope arg) {
    Scope subScope = new Scope(Scope.Type.BLOCK);
    subScope.backs.add(arg);
    super.visit(n, subScope);
    n.setData(arg);
}
 

import japa.parser.ast.stmt.BlockStmt; //导入依赖的package包/类
public ConstructorDeclaration(JavadocComment javaDoc, int modifiers, List<AnnotationExpr> annotations, List<TypeParameter> typeParameters, String name, List<Parameter> parameters, List<NameExpr> throws_, BlockStmt block) {
    super(annotations, javaDoc);
    this.modifiers = modifiers;
    this.typeParameters = typeParameters;
    this.name = name;
    this.parameters = parameters;
    this.throws_ = throws_;
    this.block = block;
}
 

import japa.parser.ast.stmt.BlockStmt; //导入依赖的package包/类
public MethodDeclaration(JavadocComment javaDoc, int modifiers, List<AnnotationExpr> annotations, List<TypeParameter> typeParameters, Type type, String name, List<Parameter> parameters, int arrayCount, List<NameExpr> throws_, boolean generator, BlockStmt block) {
    super(annotations, javaDoc);
    this.modifiers = modifiers;
    this.typeParameters = typeParameters;
    this.type = type;
    this.name = name;
    this.parameters = parameters;
    this.arrayCount = arrayCount;
    this.throws_ = throws_;
    this.generator = generator;
    this.body = block;
}
 

import japa.parser.ast.stmt.BlockStmt; //导入依赖的package包/类
public R visit(BlockStmt n, A arg) {
    if (n.getStmts() != null) {
        for (Statement s : n.getStmts()) {
            s.accept(this, arg);
        }
    }
    return null;

}
 

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

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

    return Boolean.TRUE;
}
 

import japa.parser.ast.stmt.BlockStmt; //导入依赖的package包/类
public void visit(BlockStmt n, Object arg) {
    printer.printLn("{");
    if (n.getStmts() != null) {
        printer.indent();
        for (Statement s : n.getStmts()) {
            s.accept(this, arg);
            printer.printLn();
        }
        printer.unindent();
    }
    printer.print("}");

}
 

import japa.parser.ast.stmt.BlockStmt; //导入依赖的package包/类
public void visit(BlockStmt n, A arg) {
    if (n.getStmts() != null) {
        for (Statement s : n.getStmts()) {
            s.accept(this, arg);
        }
    }
}
 

import japa.parser.ast.stmt.BlockStmt; //导入依赖的package包/类
public Node visit(BlockStmt n, A arg) {
    List<Statement> stmts = n.getStmts();
    if (stmts != null) {
        for (int i = 0; i < stmts.size(); i++) {
            stmts.set(i, (Statement) stmts.get(i).accept(this, arg));
        }
        removeNulls(stmts);
    }
    return n;
}
 

import japa.parser.ast.stmt.BlockStmt; //导入依赖的package包/类
/**
 * Adds the given statement to the specified block. The list of statements
 * will be initialized if it is <code>null</code>.
 * 
 * @param block
 * @param stmt
 */
public static void addStmt(BlockStmt block, Statement stmt) {
    List<Statement> stmts = block.getStmts();
    if (stmts == null) {
        stmts = new ArrayList<Statement>();
        block.setStmts(stmts);
    }
    stmts.add(stmt);
}