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

private Boolean expValue(JCTree exp) {
    while (exp.hasTag(PARENS))
        exp = ((JCParens)exp).expr;

    boolean eq;
    switch (exp.getTag()) {
    case EQ: eq = true;  break;
    case NE: eq = false; break;
    default:
        return null;
    }

    // we have a JCBinary(EQ|NE)
    // check if we have two literals (constants or null)
    JCBinary b = (JCBinary)exp;
    if (b.lhs.type.hasTag(BOT)) return expValueIsNull(eq, b.rhs);
    if (b.rhs.type.hasTag(BOT)) return expValueIsNull(eq, b.lhs);
    return null;
}
 

private String expr2String(JCExpression tree) {
    switch(tree.getTag()) {
        case PARENS:
            return expr2String(((JCParens)tree).expr);
        case LAMBDA:
        case REFERENCE:
        case CONDEXPR:
            return Pretty.toSimpleString(tree);
        default:
            Assert.error("unexpected tree kind " + tree.getKind());
            return null;
    }
}
 

/**
 * 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();
	}
}
 

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

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

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

public JCParens Parens(JCExpression expr) {
	return invoke(Parens, expr);
}
 

@Override
ArgumentType<JCParens> dup(JCParens tree, Env<AttrContext> env) {
    return new ParensType(tree, env, speculativeTree, speculativeTypes);
}
 

ParensType(JCExpression tree, Env<AttrContext> env, JCParens speculativeParens, Map<ResultInfo, Type> speculativeTypes) {
   super(tree, env, speculativeParens, speculativeTypes);
}
 

ParensType(JCExpression tree, Env<AttrContext> env, JCParens speculativeParens) {
    this(tree, env, speculativeParens, new HashMap<>());
}
 

@Override
public void visitParens(JCParens that) {
    processArg(that, speculativeTree -> new ParensType(that, env, speculativeTree));
}
 

private Expression convertParens(JCParens expression) {
  // Preserve the parenthesis. J2CL does not yet handle properly parenthesizing the output
  // according to operator precedence.
  return convertExpression(expression.getExpression()).parenthesize();
}
 

private Expression convertConditionRemovingOuterParentheses(JCExpression expression) {
  return convertExpression(((JCParens) expression).getExpression());
}
 

@Override
public void visitParens(JCParens tree) {
    tree.expr.accept(this);
}
 

/** Visitor method for parenthesized expressions.
 *  If the subexpression has changed, omit the parens.
 */
public void visitParens(JCParens tree) {
    JCTree expr = translate(tree.expr);
    result = ((expr == tree.expr) ? tree : expr);
}
 

public void visitParens(JCParens tree) {
    tree.expr = translate(tree.expr, pt);
    tree.type = erasure(tree.expr.type);
    result = tree;
}
 

@Override
ArgumentType<JCParens> dup(JCParens tree, Env<AttrContext> env) {
    return new ParensType(tree, env, speculativeTree, speculativeTypes);
}
 

ParensType(JCExpression tree, Env<AttrContext> env, JCParens speculativeParens, Map<ResultInfo, Type> speculativeTypes) {
   super(tree, env, speculativeParens, speculativeTypes);
}
 

ParensType(JCExpression tree, Env<AttrContext> env, JCParens speculativeParens) {
    this(tree, env, speculativeParens, new HashMap<>());
}
 

@Override
public void visitParens(JCParens that) {
    processArg(that, speculativeTree -> new ParensType(that, env, speculativeTree));
}