import com.github.javaparser.ast.expr.IntegerLiteralExpr; //导入依赖的package包/类
protected IsType extractType(Expression val) {
  if (val instanceof LiteralExpr) {
    if (val instanceof IntegerLiteralExpr) {
      return new ImmutableType("", "int");
    } else if (val instanceof LongLiteralExpr) {
      return new ImmutableType("", "long");
    } else if (val instanceof DoubleLiteralExpr) {
      return new ImmutableType("", "double");
    } else if (val instanceof CharLiteralExpr) {
      return new ImmutableType("", "char");
    } else if (val instanceof BooleanLiteralExpr) {
      return new ImmutableType("", "boolean");
    } else if (val instanceof StringLiteralExpr) {
      return new ImmutableType("java.lang", "String");
    }
    // TODO: arrays, ui containers, annotated elements, constructors, etc...
  }
  return new ImmutableType("java.lang", "Object");
}
 

import com.github.javaparser.ast.expr.IntegerLiteralExpr; //导入依赖的package包/类
private int resolveInt(Expression value) {
	if(value == null)
		return -1;
	if(value instanceof IntegerLiteralExpr) {
		return ((IntegerLiteralExpr) value).asInt();
	}
	error("Cannot get integer constant value for " + value);
	return -1;
}
 

import com.github.javaparser.ast.expr.IntegerLiteralExpr; //导入依赖的package包/类
@Override
public JCTree visit(final IntegerLiteralExpr n, final Object arg) {
    //ARG0: Object value
    Integer arg0 = new Integer(n.getValue());

    return new AJCLiteral(make.Literal(arg0), ((n.getComment() != null) ? n.getComment().getContent() : null));
}
 

import com.github.javaparser.ast.expr.IntegerLiteralExpr; //导入依赖的package包/类
@Override public Boolean visit(final IntegerLiteralExpr n1, final Node arg) {
	final IntegerLiteralExpr n2 = (IntegerLiteralExpr) arg;

	if (!objEquals(n1.getValue(), n2.getValue())) {
		return false;
	}

	return true;
}
 

import com.github.javaparser.ast.expr.IntegerLiteralExpr; //导入依赖的package包/类
@Override
public Node visit(IntegerLiteralExpr _n, Object _arg) {
	Comment comment = cloneNodes(_n.getComment(), _arg);

	IntegerLiteralExpr r = new IntegerLiteralExpr(
			_n.getRange(),
			_n.getValue()
	);
	r.setComment(comment);
	return r;
}
 

import com.github.javaparser.ast.expr.IntegerLiteralExpr; //导入依赖的package包/类
@Override
public void visit(IntegerLiteralExpr n, Script arg) {
}
 

import com.github.javaparser.ast.expr.IntegerLiteralExpr; //导入依赖的package包/类
@Override
public void visit(final IntegerLiteralExpr n, final Object arg) {
    printer.printLn("IntegerLiteralExpr");
    printJavaComment(n.getComment(), arg);
    printer.print(n.getValue());
}
 

import com.github.javaparser.ast.expr.IntegerLiteralExpr; //导入依赖的package包/类
@Override public Node visit(final IntegerLiteralExpr n, final A arg) {
	return n;
}
 

import com.github.javaparser.ast.expr.IntegerLiteralExpr; //导入依赖的package包/类
@Then("comment $commentPosition in compilation unit commented node is IntegerLiteralExpr")
public void thenCommentInCompilationUnitCommentedNodeIsIntegerLiteralExpr(int commentPosition) {
    Comment commentUnderTest = compilationUnit.getAllContainedComments().get(commentPosition - 1);
    assertThat(commentUnderTest.getCommentedNode(), instanceOf(IntegerLiteralExpr.class));
}
 

import com.github.javaparser.ast.expr.IntegerLiteralExpr; //导入依赖的package包/类
public PrimitiveDefaultValue(PrimitiveType type) {
  super("", type.getType().name());
  this.type = type;
  switch (type.getType()) {
    case Boolean:
      this.viewValue = "CHECKBOX";
      this.domainValue = createDomainValueExpression(
          new BooleanLiteralExpr(true),
          new BooleanLiteralExpr(false)
      );
      break;
    case Int:
      this.viewValue = "TEXT";
      this.domainValue = createDomainValueExpression(
          new IntegerLiteralExpr("Integer.MIN_VALUE"),
          new IntegerLiteralExpr("Integer.MAX_VALUE")
      );
      break;
    case Float:
      this.viewValue = "TEXT";
      this.domainValue = createDomainValueExpression(
          new DoubleLiteralExpr("-Float.MAX_VALUE"),
          new DoubleLiteralExpr("Float.MAX_VALUE")
      );
      break;
    case Double:
      this.viewValue = "TEXT";
      this.domainValue = createDomainValueExpression(
          new DoubleLiteralExpr("-Double.MAX_VALUE"),
          new DoubleLiteralExpr("Double.MAX_VALUE")
      );
      break;
    case Char:
      this.viewValue = "TEXT";
      this.domainValue = createDomainValueExpression(
          new CharLiteralExpr(Character.toString(Character.MIN_VALUE)),
          new CharLiteralExpr(Character.toString(Character.MAX_VALUE))
      );
      break;
    default:
      throw new UnsupportedOperationException("Type " + type.getType() + " is not supported.");
  }
}
 

import com.github.javaparser.ast.expr.IntegerLiteralExpr; //导入依赖的package包/类
private ArrayAccessExpr arrayAccessExpr(String paramId, int index) {
  return new ArrayAccessExpr(
      new NameExpr(paramId),
      new IntegerLiteralExpr(String.valueOf(index))
  );
}
 

import com.github.javaparser.ast.expr.IntegerLiteralExpr; //导入依赖的package包/类
@Override public void visit(final IntegerLiteralExpr n, final A arg) {
	visitComment(n.getComment(), arg);
}
 

import com.github.javaparser.ast.expr.IntegerLiteralExpr; //导入依赖的package包/类
@Override public Node visit(final IntegerLiteralExpr n, final A arg) {
	visitComment(n, arg);
	return n;
}
 

import com.github.javaparser.ast.expr.IntegerLiteralExpr; //导入依赖的package包/类
@Override
public Object visit(final IntegerLiteralExpr n, final Context arg) {
  return Integer.parseInt(n.getValue());
}
 

import com.github.javaparser.ast.expr.IntegerLiteralExpr; //导入依赖的package包/类
@Override
public void visit(final IntegerLiteralExpr n, final Context ctx) {
  visitNode(n, ctx);
  super.visit(n, ctx);

}
 

import com.github.javaparser.ast.expr.IntegerLiteralExpr; //导入依赖的package包/类
@Override
public Type visit(final IntegerLiteralExpr n, final Context arg) {
  return int.class;
}
 

import com.github.javaparser.ast.expr.IntegerLiteralExpr; //导入依赖的package包/类
@Override
public TypeAdapter visit(IntegerLiteralExpr n, A arg) {
    return new TypeAdapter()
        .addAdapter(int.class, IntegerLiteralExpr::intValue)
        .addAdapter(String.class, IntegerLiteralExpr::getValue);
}
 

import com.github.javaparser.ast.expr.IntegerLiteralExpr; //导入依赖的package包/类
@Override
public void visit(IntegerLiteralExpr n, Void arg) {
    out.println("IntegerLiteralExpr: " + (extended ? n : n));
    super.visit(n, arg);
}
 

import com.github.javaparser.ast.expr.IntegerLiteralExpr; //导入依赖的package包/类
@Override public IntegerLiteralExpr doMerge(IntegerLiteralExpr first, IntegerLiteralExpr second) {
  IntegerLiteralExpr ile = new IntegerLiteralExpr();

  ile.setValue(first.getValue());

  return ile;
}
 

import com.github.javaparser.ast.expr.IntegerLiteralExpr; //导入依赖的package包/类
@Override public boolean doIsEquals(IntegerLiteralExpr first, IntegerLiteralExpr second) {

    if(!first.getValue().equals(second.getValue())) return false;

    return true;
  }