com.sun.tools.javac.tree.JCTree.JCTry Java Examples

public JCStatement buildTryCatchBlock(JavacNode node, List<JCStatement> contents, String exception, JCTree source) {
	JavacTreeMaker maker = node.getTreeMaker();
	
	Context context = node.getContext();
	JCBlock tryBlock = setGeneratedBy(maker.Block(0, contents), source, context);
	JCExpression varType = chainDots(node, exception.split("\\."));
	
	JCVariableDecl catchParam = maker.VarDef(maker.Modifiers(Flags.FINAL | Flags.PARAMETER), node.toName("$ex"), varType, null);
	JCExpression lombokLombokSneakyThrowNameRef = chainDots(node, "lombok", "Lombok", "sneakyThrow");
	JCBlock catchBody = maker.Block(0, List.<JCStatement>of(maker.Throw(maker.Apply(
			List.<JCExpression>nil(), lombokLombokSneakyThrowNameRef,
			List.<JCExpression>of(maker.Ident(node.toName("$ex")))))));
	JCTry tryStatement = maker.Try(tryBlock, List.of(recursiveSetGeneratedBy(maker.Catch(catchParam, catchBody), source, context)), null);
	if (JavacHandlerUtil.inNetbeansEditor(node)) {
		//set span (start and end position) of the try statement and the main block
		//this allows NetBeans to dive into the statement correctly:
		JCCompilationUnit top = (JCCompilationUnit) node.top().get();
		int startPos = contents.head.pos;
		int endPos = Javac.getEndPosition(contents.last().pos(), top);
		tryBlock.pos = startPos;
		tryStatement.pos = startPos;
		Javac.storeEnd(tryBlock, endPos, top);
		Javac.storeEnd(tryStatement, endPos, top);
	}
	return setGeneratedBy(tryStatement, source, context);
}
 

public void visitTry(JCTry tree) {
    SourceRange sr = new SourceRange(startPos(tree), endPos(tree));
    sr.mergeWith(csp(tree.resources));
    sr.mergeWith(csp(tree.body));
    sr.mergeWith(cspCatchers(tree.catchers));
    sr.mergeWith(csp(tree.finalizer));
    result = sr;
}
 

public void visitTry(JCTry tree) {
    tree.resources = translate(tree.resources, syms.autoCloseableType);
    tree.body = translate(tree.body);
    tree.catchers = translateCatchers(tree.catchers);
    tree.finalizer = translate(tree.finalizer);
    result = tree;
}
 

public void visitTry(JCTry tree) {
    for (JCTree resource : tree.resources) {
        if (!resource.hasTag(VARDEF)) {
            Symbol var = TreeInfo.symbol(resource);
            if (var != null && (var.flags() & (FINAL | EFFECTIVELY_FINAL)) == 0) {
                log.error(resource.pos(), Errors.TryWithResourcesExprEffectivelyFinalVar(var));
            }
        }
    }
    super.visitTry(tree);
}
 

private JCStatement makeTwrCloseStatement(Symbol primaryException, JCExpression resource) {
    // primaryException.addSuppressed(catchException);
    VarSymbol catchException =
        new VarSymbol(SYNTHETIC, make.paramName(2),
                      syms.throwableType,
                      currentMethodSym);
    JCStatement addSuppressionStatement =
        make.Exec(makeCall(make.Ident(primaryException),
                           names.addSuppressed,
                           List.of(make.Ident(catchException))));

    // try { resource.close(); } catch (e) { primaryException.addSuppressed(e); }
    JCBlock tryBlock =
        make.Block(0L, List.of(makeResourceCloseInvocation(resource)));
    JCVariableDecl catchExceptionDecl = make.VarDef(catchException, null);
    JCBlock catchBlock = make.Block(0L, List.of(addSuppressionStatement));
    List<JCCatch> catchClauses = List.of(make.Catch(catchExceptionDecl, catchBlock));
    JCTry tryTree = make.Try(tryBlock, catchClauses, null);
    tryTree.finallyCanCompleteNormally = true;

    // if (primaryException != null) {try...} else resourceClose;
    JCIf closeIfStatement = make.If(makeNonNullCheck(make.Ident(primaryException)),
                                    tryTree,
                                    makeResourceCloseInvocation(resource));

    return closeIfStatement;
}
 

@Override
public void visitTry(JCTry tree) {
    if (tree.resources.nonEmpty()) {
        result = makeTwrTry(tree);
        return;
    }

    boolean hasBody = tree.body.getStatements().nonEmpty();
    boolean hasCatchers = tree.catchers.nonEmpty();
    boolean hasFinally = tree.finalizer != null &&
            tree.finalizer.getStatements().nonEmpty();

    if (!hasCatchers && !hasFinally) {
        result = translate(tree.body);
        return;
    }

    if (!hasBody) {
        if (hasFinally) {
            result = translate(tree.finalizer);
        } else {
            result = translate(tree.body);
        }
        return;
    }

    // no optimizations possible
    super.visitTry(tree);
}
 

@Override
public void visitTry(JCTry tree) {
    //skip resources (to prevents same statements to be analyzed twice)
    scan(tree.getBlock());
    scan(tree.getCatches());
    scan(tree.getFinallyBlock());
}
 

private TryStatement convertTry(JCTry statement) {
  List<JCCatch> catchClauses = statement.getCatches();

  return TryStatement.newBuilder()
      .setSourcePosition(getSourcePosition(statement))
      .setResourceDeclarations(
          statement.getResources().stream().map(this::toResource).collect(toImmutableList()))
      .setBody(convertBlock(statement.getBlock()))
      .setCatchClauses(
          catchClauses.stream().map(this::convertCatchClause).collect(toImmutableList()))
      .setFinallyBlock((Block) convertStatementOrNull(statement.getFinallyBlock()))
      .build();
}
 

private JavacNode buildTry(JCTry tryNode) {
	if (setAndGetAsHandled(tryNode)) return null;
	List<JavacNode> childNodes = new ArrayList<JavacNode>();
	for (JCTree varDecl : getResourcesForTryNode(tryNode)) {
		if (varDecl instanceof JCVariableDecl) {
			addIfNotNull(childNodes, buildLocalVar((JCVariableDecl) varDecl, Kind.LOCAL));
		}
	}
	addIfNotNull(childNodes, buildStatement(tryNode.body));
	for (JCCatch jcc : tryNode.catchers) addIfNotNull(childNodes, buildTree(jcc, Kind.STATEMENT));
	addIfNotNull(childNodes, buildStatement(tryNode.finalizer));
	return putInMap(new JavacNode(this, tryNode, childNodes, Kind.STATEMENT));
}
 

private JavacNode buildStatementOrExpression(JCTree statement) {
	if (statement == null) return null;
	if (statement instanceof JCAnnotation) return null;
	if (statement instanceof JCClassDecl) return buildType((JCClassDecl)statement);
	if (statement instanceof JCVariableDecl) return buildLocalVar((JCVariableDecl)statement, Kind.LOCAL);
	if (statement instanceof JCTry) return buildTry((JCTry) statement);
	
	if (setAndGetAsHandled(statement)) return null;
	
	return drill(statement);
}
 

private Statement convertStatement(JCStatement jcStatement) {
  switch (jcStatement.getKind()) {
    case ASSERT:
      return convertAssert((JCAssert) jcStatement);
    case BLOCK:
      return convertBlock((JCBlock) jcStatement);
    case BREAK:
      return convertBreak((JCBreak) jcStatement);
    case CLASS:
      convertClassDeclaration((JCClassDecl) jcStatement);
      return null;
    case CONTINUE:
      return convertContinue((JCContinue) jcStatement);
    case DO_WHILE_LOOP:
      return convertDoWhileLoop((JCDoWhileLoop) jcStatement);
    case EMPTY_STATEMENT:
      return new EmptyStatement(getSourcePosition(jcStatement));
    case ENHANCED_FOR_LOOP:
      return convertEnhancedForLoop((JCEnhancedForLoop) jcStatement);
    case EXPRESSION_STATEMENT:
      return convertExpressionStatement((JCExpressionStatement) jcStatement);
    case FOR_LOOP:
      return convertForLoop((JCForLoop) jcStatement);
    case IF:
      return convertIf((JCIf) jcStatement);
    case LABELED_STATEMENT:
      return convertLabeledStatement((JCLabeledStatement) jcStatement);
    case RETURN:
      return convertReturn((JCReturn) jcStatement);
    case SWITCH:
      return convertSwitch((JCSwitch) jcStatement);
    case THROW:
      return convertThrow((JCThrow) jcStatement);
    case TRY:
      return convertTry((JCTry) jcStatement);
    case VARIABLE:
      return convertVariableDeclaration((JCVariableDecl) jcStatement);
    case WHILE_LOOP:
      return convertWhileLoop((JCWhileLoop) jcStatement);
    case SYNCHRONIZED:
      return convertSynchronized((JCSynchronized) jcStatement);
    default:
      throw new AssertionError("Unknown statement node type: " + jcStatement.getKind());
  }
}
 

public JCTry Try(JCBlock body, List<JCCatch> catchers, JCBlock finalizer) {
	return invoke(Try, body, catchers, finalizer);
}
 

public JCTry Try(List<JCTree> resources, JCBlock body, List<JCCatch> catchers, JCBlock finalizer) {
	return invoke(TryWithResources, resources, body, catchers, finalizer);
}
 

/**
 * Optionally replace a try statement with the desugaring of a
 * try-with-resources statement.  The canonical desugaring of
 *
 * try ResourceSpecification
 *   Block
 *
 * is
 *
 * {
 *   final VariableModifiers_minus_final R #resource = Expression;
 *   Throwable #primaryException = null;
 *
 *   try ResourceSpecificationtail
 *     Block
 *   catch (Throwable #t) {
 *     #primaryException = t;
 *     throw #t;
 *   } finally {
 *     if (#resource != null) {
 *       if (#primaryException != null) {
 *         try {
 *           #resource.close();
 *         } catch(Throwable #suppressedException) {
 *           #primaryException.addSuppressed(#suppressedException);
 *         }
 *       } else {
 *         #resource.close();
 *       }
 *     }
 *   }
 *
 * @param tree  The try statement to inspect.
 * @return A a desugared try-with-resources tree, or the original
 * try block if there are no resources to manage.
 */
JCTree makeTwrTry(JCTry tree) {
    make_at(tree.pos());
    twrVars = twrVars.dup();
    JCBlock twrBlock = makeTwrBlock(tree.resources, tree.body,
            tree.finallyCanCompleteNormally, 0);
    if (tree.catchers.isEmpty() && tree.finalizer == null)
        result = translate(twrBlock);
    else
        result = translate(make.Try(twrBlock, tree.catchers, tree.finalizer));
    twrVars = twrVars.leave();
    return result;
}