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

public void visitThrow(JCThrow tree) {
    scan(tree.expr);
    Symbol sym = TreeInfo.symbol(tree.expr);
    if (sym != null &&
        sym.kind == VAR &&
        (sym.flags() & (FINAL | EFFECTIVELY_FINAL)) != 0 &&
        preciseRethrowTypes.get(sym) != null &&
        allowImprovedRethrowAnalysis) {
        for (Type t : preciseRethrowTypes.get(sym)) {
            markThrown(tree, t);
        }
    }
    else {
        markThrown(tree, tree.expr.type);
    }
    markDead();
}
 

public void visitThrow(JCThrow tree) {
	try {
		print("throw ");
		printExpr(tree.expr);
		print(";");
	} catch (IOException e) {
		throw new UncheckedIOException(e);
	}
}
 

/**
 * Checks if the statement is of the form 'if (x == null) {throw WHATEVER;},
 * where the block braces are optional. If it is of this form, returns "x".
 * If it is not of this form, returns null.
 */
public String returnVarNameIfNullCheck(JCStatement stat) {
	if (!(stat instanceof JCIf)) return null;
	
	/* Check that the if's statement is a throw statement, possibly in a block. */ {
		JCStatement then = ((JCIf) stat).thenpart;
		if (then instanceof JCBlock) {
			List<JCStatement> stats = ((JCBlock) then).stats;
			if (stats.length() == 0) return null;
			then = stats.get(0);
		}
		if (!(then instanceof JCThrow)) return null;
	}
	
	/* Check that the if's conditional is like 'x == null'. Return from this method (don't generate
	   a nullcheck) if 'x' is equal to our own variable's name: There's already a nullcheck here. */ {
		JCExpression cond = ((JCIf) stat).cond;
		while (cond instanceof JCParens) cond = ((JCParens) cond).expr;
		if (!(cond instanceof JCBinary)) return null;
		JCBinary bin = (JCBinary) cond;
		if (!CTC_EQUAL.equals(treeTag(bin))) return null;
		if (!(bin.lhs instanceof JCIdent)) return null;
		if (!(bin.rhs instanceof JCLiteral)) return null;
		if (!CTC_BOT.equals(typeTag(bin.rhs))) return null;
		return ((JCIdent) bin.lhs).name.toString();
	}
}
 

@Override
public void visitLambda(JCLambda tree) {
  if (tree.getBodyKind() == BodyKind.STATEMENT) {
    JCExpression ident = make.at(tree).QualIdent(symtab.assertionErrorType.tsym);
    JCThrow throwTree = make.Throw(make.NewClass(null, List.nil(), ident, List.nil(), null));
    tree.body = make.Block(0, List.of(throwTree));
  }
}
 

public void visitThrow(JCThrow tree) {
    SourceRange sr = new SourceRange(startPos(tree), endPos(tree));
    sr.mergeWith(csp(tree.expr));
    result = sr;
}
 

public void visitThrow(JCThrow tree) {
    tree.expr = translate(tree.expr, erasure(tree.expr.type));
    result = tree;
}
 

public void visitThrow(JCThrow tree) {
    scan(tree.expr);
    markDead();
}
 

public void visitThrow(JCThrow tree) {
    scanExpr(tree.expr);
    markDead();
}
 

private ThrowStatement convertThrow(JCThrow statement) {
  return new ThrowStatement(
      getSourcePosition(statement), convertExpression(statement.getExpression()));
}
 

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 JCThrow Throw(JCExpression expr) {
	return invoke(Throw, expr);
}
 

@Override
public JCThrow inline(Inliner inliner) throws CouldNotResolveImportException {
  return inliner.maker().Throw(getExpression().inline(inliner));
}