コード例 #1
0
 private TryCatchStatement tryCatchAssertionFailedError(
     AnnotationNode annotationNode, MethodNode methodNode, ArrayList<Statement> statements) {
   TryCatchStatement tryCatchStatement =
       new TryCatchStatement(
           new BlockStatement(statements, methodNode.getVariableScope()), EmptyStatement.INSTANCE);
   tryCatchStatement.addCatch(
       new CatchStatement(
           new Parameter(CATCHED_THROWABLE_TYPE, "ex"), ReturnStatement.RETURN_NULL_OR_VOID));
   return tryCatchStatement;
 }
コード例 #2
0
 public void visitTryCatchFinally(TryCatchStatement statement) {
   statement.getTryStatement().visit(this);
   for (CatchStatement catchStatement : statement.getCatchStatements()) {
     catchStatement.visit(this);
   }
   Statement finallyStatement = statement.getFinallyStatement();
   if (finallyStatement instanceof EmptyStatement) {
     // dispatching to EmptyStatement will not call back visitor,
     // must call our visitEmptyStatement explicitly
     visitEmptyStatement((EmptyStatement) finallyStatement);
   } else {
     finallyStatement.visit(this);
   }
 }
コード例 #3
0
  private void createValidateMethod() {
    Validation.Mode mode =
        getEnumMemberValue(
            getAnnotation(annotatedClass, VALIDATION_ANNOTATION),
            "mode",
            Validation.Mode.class,
            Validation.Mode.AUTOMATIC);

    annotatedClass.addField(
        "$manualValidation",
        ACC_PRIVATE,
        ClassHelper.Boolean_TYPE,
        new ConstantExpression(mode == Validation.Mode.MANUAL));
    MethodBuilder.createPublicMethod("manualValidation")
        .param(Boolean_TYPE, "validation")
        .assignS(varX("$manualValidation"), varX("validation"))
        .addTo(annotatedClass);

    MethodBuilder methodBuilder = MethodBuilder.createPublicMethod(VALIDATE_METHOD);

    if (ASTHelper.isDSLObject(annotatedClass.getSuperClass())) {
      methodBuilder.statement(callSuperX(VALIDATE_METHOD));
    }

    BlockStatement block = new BlockStatement();
    validateFields(block);
    validateCustomMethods(block);

    TryCatchStatement tryCatchStatement = new TryCatchStatement(block, EmptyStatement.INSTANCE);
    tryCatchStatement.addCatch(
        new CatchStatement(
            param(ASSERTION_ERROR_TYPE, "e"),
            new ThrowStatement(
                ctorX(VALIDATION_EXCEPTION_TYPE, args(propX(varX("e"), "message"), varX("e"))))));
    tryCatchStatement.addCatch(
        new CatchStatement(
            param(EXCEPTION_TYPE, "e"),
            new ThrowStatement(
                ctorX(VALIDATION_EXCEPTION_TYPE, args(propX(varX("e"), "message"), varX("e"))))));

    methodBuilder.statement(tryCatchStatement).addTo(annotatedClass);
  }
コード例 #4
0
ファイル: GrailsASTUtils.java プロジェクト: erdi/grails-core
 /**
  * Wraps a method body in try / catch logic that catches any errors and logs an error, but does
  * not rethrow!
  *
  * @param methodNode The method node
  */
 public static void wrapMethodBodyInTryCatchDebugStatements(MethodNode methodNode) {
   BlockStatement code = (BlockStatement) methodNode.getCode();
   BlockStatement newCode = new BlockStatement();
   TryCatchStatement tryCatchStatement = new TryCatchStatement(code, new BlockStatement());
   newCode.addStatement(tryCatchStatement);
   methodNode.setCode(newCode);
   BlockStatement catchBlock = new BlockStatement();
   ArgumentListExpression logArguments = new ArgumentListExpression();
   logArguments.addExpression(
       new BinaryExpression(
           new ConstantExpression("Error initializing class: "),
           Token.newSymbol(Types.PLUS, 0, 0),
           new VariableExpression("e")));
   logArguments.addExpression(new VariableExpression("e"));
   catchBlock.addStatement(
       new ExpressionStatement(
           new MethodCallExpression(new VariableExpression("log"), "error", logArguments)));
   tryCatchStatement.addCatch(
       new CatchStatement(new Parameter(new ClassNode(Throwable.class), "e"), catchBlock));
 }
コード例 #5
0
 @Override
 public void visitTryCatchFinally(final TryCatchStatement statement) {
   visitStatement(statement);
   Map<Variable, VariableState> beforeTryCatch = new HashMap<Variable, VariableState>(getState());
   statement.getTryStatement().visit(this);
   for (CatchStatement catchStatement : statement.getCatchStatements()) {
     catchStatement.visit(this);
   }
   Statement finallyStatement = statement.getFinallyStatement();
   // we need to recall which final variables are unassigned so cloning the current state
   Map<Variable, VariableState> afterTryCatchState =
       new HashMap<Variable, VariableState>(getState());
   if (finallyStatement instanceof EmptyStatement) {
     // dispatching to EmptyStatement will not call back visitor,
     // must call our visitEmptyStatement explicitly
     visitEmptyStatement((EmptyStatement) finallyStatement);
   } else {
     finallyStatement.visit(this);
   }
   // and now we must reset to uninitialized state variables which were only initialized during
   // try/catch
   Map<Variable, VariableState> afterFinally = new HashMap<Variable, VariableState>(getState());
   for (Map.Entry<Variable, VariableState> entry : afterFinally.entrySet()) {
     Variable var = entry.getKey();
     VariableState afterFinallyState = entry.getValue();
     VariableState beforeTryCatchState = beforeTryCatch.get(var);
     if (afterFinallyState == VariableState.is_final
         && beforeTryCatchState != VariableState.is_final
         && afterTryCatchState.get(var) != beforeTryCatchState) {
       getState()
           .put(
               var,
               beforeTryCatchState == null ? VariableState.is_uninitialized : beforeTryCatchState);
     }
   }
 }