import japa.parser.ast.stmt.ReturnStmt; //导入依赖的package包/类
/**
 * Add a statement to the given state.
 */
void addStatement(int state, Statement stmt) {
    List<Statement> stmts = this.states.get(state).getStmts();

    if (stmts.size() > 0) {
        Statement lastStmt = stmts.get(stmts.size() - 1);
        // Preemptively eliminate dead code.
        if (lastStmt.getClass().equals(ReturnStmt.class) ||
            lastStmt.getClass().equals(ThrowStmt.class) ||
            lastStmt.getClass().equals(BreakStmt.class) ||
            lastStmt.getClass().equals(ContinueStmt.class)) {
            return;
        }
    }

    stmts.add(stmt);
}
 

import japa.parser.ast.stmt.ReturnStmt; //导入依赖的package包/类
/**
 * Transform a yield.
 */
@Override
public void visit(YieldStmt n, Generator s) {
    // Remember the state to add the deferred jump to.
    int entryState = s.getCurrentState();
    s.newState();

    s.addStatement(entryState, Generator.generateDeferredJump(s.getCurrentState()));
    s.addStatement(entryState, new ExpressionStmt(new AssignExpr(Generator.CURRENT_VAR,
                                                  n.getExpr(),
                                                  AssignExpr.Operator.assign)));
    s.addStatement(entryState, new ReturnStmt(new BooleanLiteralExpr(true)));
}
 

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

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

    return Boolean.TRUE;
}
 

import japa.parser.ast.stmt.ReturnStmt; //导入依赖的package包/类
public void visit(ReturnStmt n, Object arg) {
    printer.print("return");
    if (n.getExpr() != null) {
        printer.print(" ");
        n.getExpr().accept(this, arg);
    }
    printer.print(";");
}
 

import japa.parser.ast.stmt.ReturnStmt; //导入依赖的package包/类
@Override
public MethodDeclaration visit(MethodDeclaration n, Void arg) {
    if (!n.isGenerator()) {
        throw new UnsupportedOperationException("cannot transform non-generator");
    }

    // Desugar ALL the loops!
    n.accept(new LoopDesugarTransform(), null);
    if (CompilerSettings.dumpDesugar) {
        System.err.println(n);
    }

    Generator g = new Generator();
    Map<String, TypedVariableDeclarator> vars = new HashMap<String, TypedVariableDeclarator>();

    // Mangle all our scope variables.
    n.accept(new ScopeMangleTransform(), vars);
    if (CompilerSettings.dumpMangle) {
        System.err.println(n);
    }

    // Generate the body.
    n.accept(new LinearizeTransform(), g);

    List<BodyDeclaration> generatorBody = new ArrayList<BodyDeclaration>();

    // Add the fields to the generator body.
    for (Map.Entry<String, TypedVariableDeclarator> kv : vars.entrySet()) {
        VariableDeclarator decl = new VariableDeclarator(new VariableDeclaratorId(kv.getKey()), null);
        generatorBody.add(new FieldDeclaration(ModifierSet.PRIVATE, kv.getValue().type, decl));
    }

    // Add the moveNext method to the generator body.
    generatorBody.add(new MethodDeclaration(0, 0, 0, 0, null, ModifierSet.PROTECTED,
                                            null, null, new PrimitiveType(Primitive.Boolean),
                                            "moveNext", null, 0, null, false,
                                            new BlockStmt(g.generate())));

    ObjectCreationExpr o = new ObjectCreationExpr(0, 0, 0, 0, null, makeRtGeneratorType(n.getType()), null, null, generatorBody);
    List<Statement> methodBody = new ArrayList<Statement>();
    methodBody.add(new ReturnStmt(o));
    MethodDeclaration n2 = new MethodDeclaration(n.getBeginLine(),
            n.getBeginColumn(),
            n.getEndLine(),
            n.getEndColumn(),
            n.getJavaDoc(),
            n.getModifiers(),
            n.getAnnotations(),
            n.getTypeParameters(),
            makeRtGeneratorType(n.getType()),
            n.getName(),
            n.getParameters(),
            n.getArrayCount(),
            n.getThrows(),
            false,
            new BlockStmt(methodBody));

    return n2;
}
 

import japa.parser.ast.stmt.ReturnStmt; //导入依赖的package包/类
@Override
public Boolean visit(ReturnStmt n, Void arg) {
    NodeAnnotation nodeAnnotation = new NodeAnnotation(true);
    n.setData(nodeAnnotation);
    return true;
}
 

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

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

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

import japa.parser.ast.stmt.ReturnStmt; //导入依赖的package包/类
public Node visit(ReturnStmt n, A arg) {
    if (n.getExpr() != null) {
        n.setExpr((Expression) n.getExpr().accept(this, arg));
    }
    return n;
}
 

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

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

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

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

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

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

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