Java ExpressionStmt类代码示例

import com.github.javaparser.ast.stmt.ExpressionStmt; //导入依赖的package包/类
Map<String, Class<?>> getTypesByVariableName( List<Statement> statements ) {
    Map<String, Class<?>> typeByVariableName = new HashMap<>();

    for (Statement statement : statements) {
        if ( statement instanceof ExpressionStmt ) {
            Expression expression = ( ( ExpressionStmt ) statement ).getExpression();
            if ( expression instanceof VariableDeclarationExpr ) {
                VariableDeclarationExpr varExpression = ( VariableDeclarationExpr ) expression;

                @Nullable Class<?> type = typeOf( varExpression.getType() );

                if ( type != null ) {
                    for (VariableDeclarator var : varExpression.getVars()) {
                        typeByVariableName.put( var.getId().getName(), type );
                    }
                }
            }
        }
    }

    return typeByVariableName;
}
 

import com.github.javaparser.ast.stmt.ExpressionStmt; //导入依赖的package包/类
private MethodDeclaration setterDeclaration(EntityField field) {
    MethodDeclaration decl = new MethodDeclaration(ModifierSet.PUBLIC,
            new VoidType(),
            "set" + CaseConverter.pascalCase(field.getName()),
            Collections.singletonList(new Parameter(
                    ASTHelper.createReferenceType(field.getType().getSimpleName(), 0),
                    new VariableDeclaratorId(field.getName()))));

    BlockStmt body = new BlockStmt();
    body.setStmts(
            Collections.singletonList(
                    new ExpressionStmt(
                            new AssignExpr(
                                    new FieldAccessExpr(new ThisExpr(), field.getName()),
                                    ASTHelper.createNameExpr(field.getName()),
                                    AssignExpr.Operator.assign
                            ))));
    decl.setBody(body);
    return decl;
}
 

import com.github.javaparser.ast.stmt.ExpressionStmt; //导入依赖的package包/类
@Override
public Node visit(final ExpressionStmt n, Object arg) {
    // VariableDeclarationExpr contains a list of variable declaration
    // Unfolding it to several elements
    Node myresult = n.getExpression().accept(this, arg);

    // Checking if type is the expected one. Should be careful here.
    if (myresult instanceof ListVariableDeclarationExpr) {
        Vector<ExpressionStmt> mydecllist = new Vector<ExpressionStmt>();

        for (final VariableDeclarationExpr newexpr : ((ListVariableDeclarationExpr) myresult).getVarExprs()) {

            // Build an ExpressionStmt with same metadata as n
            ExpressionStmt mynewstmt = ListExpressionStmt.makeClone(n);
            // Set the unfolded variable declaration expression
            mynewstmt.setExpression(newexpr);

            mydecllist.add(mynewstmt);
        }

        return new ListExpressionStmt(mydecllist);
    } else {
        n.setExpression((Expression) myresult);
        return n;
    }
}
 

import com.github.javaparser.ast.stmt.ExpressionStmt; //导入依赖的package包/类
protected static ExpressionStmt makeClone(ExpressionStmt n) {
    ExpressionStmt myclone = new ExpressionStmt(n.getBeginLine(),
            n.getBeginColumn(),
            n.getEndLine(),
            n.getEndColumn(),
            n.getExpression());
    // Clone class members inherited from Node
    myclone.setParentNode(n.getParentNode());
    myclone.setData(n.getData());
    myclone.setComment(n.getComment());
    // Orphan comments should be added one by one
    for (final Comment c : n.getOrphanComments()) {
        myclone.addOrphanComment(c);
    }

    return myclone;
}
 

import com.github.javaparser.ast.stmt.ExpressionStmt; //导入依赖的package包/类
@Override
public Expression getDefaultValue(String defaultValue) {
  if (!this.defaultValues.isEmpty()) {
    LambdaExpr provider = new LambdaExpr();
    provider.setBody(
        new ExpressionStmt(
            new ObjectCreationExpr(null, type, defaultValues)
        )
    );
    provider.setParametersEnclosed(true);
    return provider;
  } else {
    MethodReferenceExpr referenceExpr = new MethodReferenceExpr();
    referenceExpr.setScope(new NameExpr(type.getName()));
    referenceExpr.setIdentifier("new");
    return referenceExpr;
  }
}
 

import com.github.javaparser.ast.stmt.ExpressionStmt; //导入依赖的package包/类
@Test
public void accessClassFieldThroughThisWithCompetingSymbolInParentContext() throws ParseException {
    CompilationUnit cu = parseSample("AccessClassMemberThroughThis");
    com.github.javaparser.ast.body.ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "AccessClassMemberThroughThis");
    MethodDeclaration method = Navigator.demandMethod(clazz, "setLabel");
    ExpressionStmt expressionStmt = (ExpressionStmt) method.getBody().get().getStatements().get(0);
    AssignExpr assignExpr = (AssignExpr) expressionStmt.getExpression();
    FieldAccessExpr fieldAccessExpr = (FieldAccessExpr) assignExpr.getTarget();

    File src = adaptPath(new File("src/test/resources"));
    CombinedTypeSolver typeSolver = new CombinedTypeSolver(new JavaParserTypeSolver(src), new ReflectionTypeSolver());
    SymbolSolver symbolSolver = new SymbolSolver(typeSolver);
    SymbolReference<? extends ResolvedValueDeclaration> ref = symbolSolver.solveSymbol(fieldAccessExpr.getField().getId(), fieldAccessExpr);

    assertTrue(ref.isSolved());
    assertTrue(ref.getCorrespondingDeclaration().isField());
}
 

import com.github.javaparser.ast.stmt.ExpressionStmt; //导入依赖的package包/类
@Test
public void resolveUsageOfGenericFieldAdvancedCase() throws ParseException {
    CompilationUnit cu = parseSample("Generics");
    ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "SomeCollection");

    MethodDeclaration method = Navigator.demandMethod(clazz, "foo2");

    ExpressionStmt stmt = (ExpressionStmt) method.getBody().get().getStatements().get(0);
    Expression expression = stmt.getExpression();
    ResolvedType type = JavaParserFacade.get(new ReflectionTypeSolver()).getType(expression);

    assertEquals(false, type.isTypeVariable());
    assertEquals("java.util.List<java.lang.String>", type.describe());
    assertEquals(1, type.asReferenceType().typeParametersValues().size());
    assertEquals(false, type.asReferenceType().typeParametersValues().get(0).isTypeVariable());
    assertEquals("java.lang.String", type.asReferenceType().typeParametersValues().get(0).describe());
}
 

import com.github.javaparser.ast.stmt.ExpressionStmt; //导入依赖的package包/类
private static boolean appearsInAssignmentContext(Expression expression) {
    if (expression.getParentNode().isPresent()) {
        Node parent = expression.getParentNode().get();
        if (parent instanceof ExpressionStmt) {
            return false;
        }
        if (parent instanceof MethodCallExpr) {
            return false;
        }
        if (parent instanceof ReturnStmt) {
            return false;
        }
        throw new UnsupportedOperationException(parent.getClass().getCanonicalName());
    }
    return false;
}
 

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

import com.github.javaparser.ast.stmt.ExpressionStmt; //导入依赖的package包/类
@Override
public JCTree visit(final ExpressionStmt n, final Object arg) {
    //ARG0: JCExpression expr
    JCExpression arg0;

    JCTree mystmt = n.getExpression().accept(this, arg);

    // Adding commment if
    // 1 - There's actualy a comment to add
    // 2 - The variable doesn't have a comment yet
    // 3 - It is a variable declaration
    if ((n.getComment() != null) &&
            (mystmt instanceof AJCVariableDecl) &&
            (!((AJCVariableDecl) mystmt).hasComment())) {

        ((AJCVariableDecl) mystmt).setComment(n.getComment().getContent());
    }

    // Case where the expression is already a subclass of JCStatement, such as JCVariableDecl
    if (mystmt instanceof JCStatement) {
        return mystmt;
    }

    arg0 = (JCExpression) mystmt;

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

import com.github.javaparser.ast.stmt.ExpressionStmt; //导入依赖的package包/类
@Override
public R visit(final ExpressionStmt n, final A arg) {
	{
		R result = n.getExpression().accept(this, arg);
		if (result != null) {
			return result;
		}
	}
	return null;
}
 

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

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

	return Boolean.TRUE;
}
 

import com.github.javaparser.ast.stmt.ExpressionStmt; //导入依赖的package包/类
@Override
public void visit(LambdaExpr n, Object arg) {
       printJavaComment(n.getComment(), arg);

       List<Parameter> parameters = n.getParameters();
boolean printPar = false;
printPar = n.isParametersEnclosed();

if (printPar) {
    printer.print("(");
}
if (parameters != null) {
    for (Iterator<Parameter> i = parameters.iterator(); i.hasNext();) {
	Parameter p = i.next();
	p.accept(this, arg);
	if (i.hasNext()) {
	    printer.print(", ");
	}
    }
}
if (printPar) {
    printer.print(")");
}

printer.print(" -> ");
Statement body = n.getBody();
if (body instanceof ExpressionStmt) {
    // Print the expression directly
    ((ExpressionStmt) body).getExpression().accept(this, arg);
} else {
    body.accept(this, arg);
}
   }
 

import com.github.javaparser.ast.stmt.ExpressionStmt; //导入依赖的package包/类
private ClassOrInterfaceDeclaration getClassDeclaration() {
  final ClassOrInterfaceType eventBusType = new ClassOrInterfaceType("EventBus");
  final ClassOrInterfaceType eventType = new ClassOrInterfaceType("OperationAddedEvent");

  // This method is how the generated code tells the rest of the application about all of the
  // generated OpenCV
  // operations. It sends an OperationAddedEvent with a new instance of every operation.
  final MethodDeclaration addOperations = new MethodDeclaration(ModifierSet.PUBLIC |
      ModifierSet.STATIC,
      new VoidType(), "addOperations");

  ASTHelper.addParameter(addOperations, ASTHelper.createParameter(eventBusType, "eventBus"));

  addOperations.setBody(new BlockStmt(this.operations.stream()
      .sorted((o1, o2) -> o1.getOperationClassName().toLowerCase().compareToIgnoreCase(o2
          .getOperationClassName()))
      .map(Operation::getOperationClassName)
      .map(ClassOrInterfaceType::new)
      // Create a new instance of each operation
      .map(type -> new ObjectCreationExpr(null, type, null))
      // Create a new OperationAddedEvent for every operation
      .map(expr -> new ObjectCreationExpr(null, eventType, Collections.singletonList(expr)))
      // Post all of the events to the event bus
      .map(expr -> new MethodCallExpr(new NameExpr("eventBus"), "post", Collections
          .singletonList(expr)))
      .map(ExpressionStmt::new)
      .collect(Collectors.toList())));

  final ClassOrInterfaceDeclaration cvoperations = new ClassOrInterfaceDeclaration(ModifierSet
      .PUBLIC, false,
      "CVOperations");
  cvoperations.setMembers(Collections.singletonList(addOperations));
  return cvoperations;
}
 

import com.github.javaparser.ast.stmt.ExpressionStmt; //导入依赖的package包/类
@Test(expected = UnsolvedSymbolException.class)
public void issue144() throws ParseException {
    CompilationUnit cu = parseSampleWithStandardExtension("issue144/HelloWorld");
    ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "HelloWorld");
    ExpressionStmt expressionStmt = (ExpressionStmt)clazz.getMethodsByName("main").get(0).getBody().get().getStatement(0);
    MethodCallExpr methodCallExpr = (MethodCallExpr) expressionStmt.getExpression();
    Expression firstParameter = methodCallExpr.getArgument(0);
    JavaParserFacade javaParserFacade = JavaParserFacade.get(typeSolver);

    javaParserFacade.solve(firstParameter).isSolved();
}