import japa.parser.ast.type.PrimitiveType; //导入依赖的package包/类
@Override
public JType visit(PrimitiveType type, JCodeModel codeModel) {
	switch (type.getType()) {
	case Boolean:
		return codeModel.BOOLEAN;
	case Char:
		return codeModel.CHAR;
	case Byte:
		return codeModel.BYTE;
	case Short:
		return codeModel.SHORT;
	case Int:
		return codeModel.INT;
	case Long:
		return codeModel.LONG;
	case Float:
		return codeModel.FLOAT;
	case Double:
		return codeModel.DOUBLE;
	default:
		throw new AssertionError("Unknown primitive type ["
				+ type.getType() + "]");
	}
}
 

import japa.parser.ast.type.PrimitiveType; //导入依赖的package包/类
private static String getRawTypeName(Type type) {
	if (type instanceof ClassOrInterfaceType) {
		return getQualifiedName((ClassOrInterfaceType) type);
	}
	if (type instanceof ReferenceType) {
		ReferenceType refType = (ReferenceType) type;
		return getRawTypeName(refType.getType()) + StringUtils.multiply("[]", refType.getArrayCount());
	}
	if (type instanceof PrimitiveType) {
		return ((PrimitiveType) type).getType().name().toLowerCase();
	}
	if (type instanceof VoidType) {
		return "void";
	}
	if (type instanceof WildcardType) {
		return "java.lang.Object";
	}
	return type.toString();
}
 

import japa.parser.ast.type.PrimitiveType; //导入依赖的package包/类
/**
 * Given a primitive type, computes the corresponding Java Parser type.
 * <p>
 * Presenting a non-primitive type to this method will throw an exception.
 * If you have a non-primitive type, use
 * {@link #importTypeIfRequired(JavaType, List, JavaType)} and then present
 * the {@link NameExpr} it returns to
 * {@link #getClassOrInterfaceType(NameExpr)}.
 * 
 * @param javaType a primitive type (required, and must be primitive)
 * @return the equivalent Java Parser {@link Type}
 */
public static Type getType(final JavaType javaType) {
    Validate.notNull(javaType, "Java type required");
    Validate.isTrue(javaType.isPrimitive(),
            "Java type must be primitive to be presented to this method");
    if (javaType.equals(JavaType.VOID_PRIMITIVE)) {
        return new VoidType();
    }
    else if (javaType.equals(JavaType.BOOLEAN_PRIMITIVE)) {
        return new PrimitiveType(Primitive.Boolean);
    }
    else if (javaType.equals(JavaType.BYTE_PRIMITIVE)) {
        return new PrimitiveType(Primitive.Byte);
    }
    else if (javaType.equals(JavaType.CHAR_PRIMITIVE)) {
        return new PrimitiveType(Primitive.Char);
    }
    else if (javaType.equals(JavaType.DOUBLE_PRIMITIVE)) {
        return new PrimitiveType(Primitive.Double);
    }
    else if (javaType.equals(JavaType.FLOAT_PRIMITIVE)) {
        return new PrimitiveType(Primitive.Float);
    }
    else if (javaType.equals(JavaType.INT_PRIMITIVE)) {
        return new PrimitiveType(Primitive.Int);
    }
    else if (javaType.equals(JavaType.LONG_PRIMITIVE)) {
        return new PrimitiveType(Primitive.Long);
    }
    else if (javaType.equals(JavaType.SHORT_PRIMITIVE)) {
        return new PrimitiveType(Primitive.Short);
    }
    throw new IllegalStateException("Unknown primitive " + javaType);
}
 

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

    if (n1.getType() != n2.getType()) {
        return Boolean.FALSE;
    }

    return Boolean.TRUE;
}
 

import japa.parser.ast.type.PrimitiveType; //导入依赖的package包/类
public void visit(PrimitiveType n, Object arg) {
    switch (n.getType()) {
        case Boolean:
            printer.print("boolean");
            break;
        case Byte:
            printer.print("byte");
            break;
        case Char:
            printer.print("char");
            break;
        case Double:
            printer.print("double");
            break;
        case Float:
            printer.print("float");
            break;
        case Int:
            printer.print("int");
            break;
        case Long:
            printer.print("long");
            break;
        case Short:
            printer.print("short");
            break;
    }
}
 

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

import japa.parser.ast.type.PrimitiveType; //导入依赖的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.type.PrimitiveType; //导入依赖的package包/类
@Override
public Boolean visit(PrimitiveType n, Void arg) {
    return false;
}
 

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

import japa.parser.ast.type.PrimitiveType; //导入依赖的package包/类
public R visit(PrimitiveType n, A arg) {
    return null;
}
 

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

import japa.parser.ast.type.PrimitiveType; //导入依赖的package包/类
public Node visit(PrimitiveType n, A arg) {
    return n;
}
 

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

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

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

import japa.parser.ast.type.PrimitiveType; //导入依赖的package包/类
/**
 * Creates a new {@link ReferenceType} for the given primitive type.
 * 
 * @param type
 *            primitive type
 * @param arrayCount
 *            number os arrays or <code>0</code> if is not a array.
 * @return instanceof {@link ReferenceType}
 */
public static ReferenceType createReferenceType(PrimitiveType type, int arrayCount) {
    return new ReferenceType(type, arrayCount);
}
 

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

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

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

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