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

/** Visitor method for conditional expressions.
 */
@Override
public void visitConditional(JCConditional tree) {
    JCTree cond = tree.cond = translate(tree.cond, syms.booleanType);
    if (isTrue(cond)) {
        result = convert(translate(tree.truepart, tree.type), tree.type);
        addPrunedInfo(cond);
    } else if (isFalse(cond)) {
        result = convert(translate(tree.falsepart, tree.type), tree.type);
        addPrunedInfo(cond);
    } else {
        // Condition is not a compile-time constant.
        tree.truepart = translate(tree.truepart, tree.type);
        tree.falsepart = translate(tree.falsepart, tree.type);
        result = tree;
    }
}
 

public void visitConditional(JCConditional tree) {
    SourceRange sr = new SourceRange(startPos(tree), endPos(tree));
    sr.mergeWith(csp(tree.cond));
    sr.mergeWith(csp(tree.truepart));
    sr.mergeWith(csp(tree.falsepart));
    result = sr;
}
 

@Override
public JCConditional inline(Inliner inliner) throws CouldNotResolveImportException {
  return inliner.maker().Conditional(
      getCondition().inline(inliner),
      getTrueExpression().inline(inliner), 
      getFalseExpression().inline(inliner));
}
 

public void visitConditional(JCConditional tree) {
	try {
		open(prec, TreeInfo.condPrec);
		printExpr(tree.cond, TreeInfo.condPrec);
		print(" ? ");
		printExpr(tree.truepart, TreeInfo.condPrec);
		print(" : ");
		printExpr(tree.falsepart, TreeInfo.condPrec);
		close(prec, TreeInfo.condPrec);
	} catch (IOException e) {
		throw new UncheckedIOException(e);
	}
}
 

public void visitConditional(JCConditional tree) {
    tree.cond = translate(tree.cond, syms.booleanType);
    tree.truepart = translate(tree.truepart, erasure(tree.type));
    tree.falsepart = translate(tree.falsepart, erasure(tree.type));
    tree.type = erasure(tree.type);
    result = retype(tree, tree.type, pt);
}
 

public void visitConditional(JCConditional tree) {
    scanCond(tree.cond);
    final Bits initsBeforeElse = new Bits(initsWhenFalse);
    final Bits uninitsBeforeElse = new Bits(uninitsWhenFalse);
    inits.assign(initsWhenTrue);
    uninits.assign(uninitsWhenTrue);
    if (tree.truepart.type.hasTag(BOOLEAN) &&
        tree.falsepart.type.hasTag(BOOLEAN)) {
        // if b and c are boolean valued, then
        // v is (un)assigned after a?b:c when true iff
        //    v is (un)assigned after b when true and
        //    v is (un)assigned after c when true
        scanCond(tree.truepart);
        final Bits initsAfterThenWhenTrue = new Bits(initsWhenTrue);
        final Bits initsAfterThenWhenFalse = new Bits(initsWhenFalse);
        final Bits uninitsAfterThenWhenTrue = new Bits(uninitsWhenTrue);
        final Bits uninitsAfterThenWhenFalse = new Bits(uninitsWhenFalse);
        inits.assign(initsBeforeElse);
        uninits.assign(uninitsBeforeElse);
        scanCond(tree.falsepart);
        initsWhenTrue.andSet(initsAfterThenWhenTrue);
        initsWhenFalse.andSet(initsAfterThenWhenFalse);
        uninitsWhenTrue.andSet(uninitsAfterThenWhenTrue);
        uninitsWhenFalse.andSet(uninitsAfterThenWhenFalse);
    } else {
        scanExpr(tree.truepart);
        final Bits initsAfterThen = new Bits(inits);
        final Bits uninitsAfterThen = new Bits(uninits);
        inits.assign(initsBeforeElse);
        uninits.assign(uninitsBeforeElse);
        scanExpr(tree.falsepart);
        inits.andSet(initsAfterThen);
        uninits.andSet(uninitsAfterThen);
    }
}
 

private ConditionalExpression convertConditional(JCConditional conditionalExpression) {
  return ConditionalExpression.newBuilder()
      .setTypeDescriptor(environment.createTypeDescriptor(conditionalExpression.type))
      .setConditionExpression(convertExpression(conditionalExpression.getCondition()))
      .setTrueExpression(convertExpression(conditionalExpression.getTrueExpression()))
      .setFalseExpression(convertExpression(conditionalExpression.getFalseExpression()))
      .build();
}
 

/**
 * Returns the precedence level appropriate for unambiguously printing
 * leaf as a subexpression of its parent.
 */
private static int getPrecedence(JCTree leaf, Context context) {
  JCCompilationUnit comp = context.get(JCCompilationUnit.class);
  JCTree parent = TreeInfo.pathFor(leaf, comp).get(1);

  // In general, this should match the logic in com.sun.tools.javac.tree.Pretty.
  //
  // TODO(mdempsky): There are probably cases where we could omit parentheses
  // by tweaking the returned precedence, but they need careful review.
  // For example, consider a template to replace "add(a, b)" with "a + b",
  // which applied to "x + add(y, z)" would result in "x + (y + z)".
  // In most cases, we'd likely prefer "x + y + z" instead, but those aren't
  // always equivalent: "0L + (Integer.MIN_VALUE + Integer.MIN_VALUE)" yields
  // a different value than "0L + Integer.MIN_VALUE + Integer.MIN_VALUE" due
  // to integer promotion rules.

  if (parent instanceof JCConditional) {
    // This intentionally differs from Pretty, because Pretty appears buggy:
    // http://mail.openjdk.java.net/pipermail/compiler-dev/2013-September/007303.html
    JCConditional conditional = (JCConditional) parent;
    return TreeInfo.condPrec + ((conditional.cond == leaf) ? 1 : 0);
  } else if (parent instanceof JCAssign) {
    JCAssign assign = (JCAssign) parent;
    return TreeInfo.assignPrec + ((assign.lhs == leaf) ? 1 : 0);
  } else if (parent instanceof JCAssignOp) {
    JCAssignOp assignOp = (JCAssignOp) parent;
    return TreeInfo.assignopPrec + ((assignOp.lhs == leaf) ? 1 : 0);
  } else if (parent instanceof JCUnary) {
    return TreeInfo.opPrec(parent.getTag());
  } else if (parent instanceof JCBinary) {
    JCBinary binary = (JCBinary) parent;
    return TreeInfo.opPrec(parent.getTag()) + ((binary.rhs == leaf) ? 1 : 0);
  } else if (parent instanceof JCTypeCast) {
    JCTypeCast typeCast = (JCTypeCast) parent;
    return (typeCast.expr == leaf) ? TreeInfo.prefixPrec : TreeInfo.noPrec;
  } else if (parent instanceof JCInstanceOf) {
    JCInstanceOf instanceOf = (JCInstanceOf) parent;
    return TreeInfo.ordPrec + ((instanceOf.clazz == leaf) ? 1 : 0);
  } else if (parent instanceof JCArrayAccess) {
    JCArrayAccess arrayAccess = (JCArrayAccess) parent;
    return (arrayAccess.indexed == leaf) ? TreeInfo.postfixPrec : TreeInfo.noPrec;
  } else if (parent instanceof JCFieldAccess) {
    JCFieldAccess fieldAccess = (JCFieldAccess) parent;
    return (fieldAccess.selected == leaf) ? TreeInfo.postfixPrec : TreeInfo.noPrec;
  } else {
    return TreeInfo.noPrec;
  }
}
 

public JCMethodDecl createWither(long access, JavacNode field, JavacTreeMaker maker, JavacNode source, List<JCAnnotation> onMethod, List<JCAnnotation> onParam) {
	String witherName = toWitherName(field);
	if (witherName == null) return null;
	
	JCVariableDecl fieldDecl = (JCVariableDecl) field.get();
	
	ListBuffer<JCStatement> statements = new ListBuffer<JCStatement>();
	List<JCAnnotation> nonNulls = findAnnotations(field, NON_NULL_PATTERN);
	List<JCAnnotation> nullables = findAnnotations(field, NULLABLE_PATTERN);
	
	Name methodName = field.toName(witherName);
	List<JCAnnotation> annsOnParam = copyAnnotations(onParam).appendList(nonNulls).appendList(nullables);
	
	long flags = JavacHandlerUtil.addFinalIfNeeded(Flags.PARAMETER, field.getContext());
	JCVariableDecl param = maker.VarDef(maker.Modifiers(flags, annsOnParam), fieldDecl.name, fieldDecl.vartype, null);
	
	JCExpression selfType = cloneSelfType(field);
	if (selfType == null) return null;
	
	ListBuffer<JCExpression> args = new ListBuffer<JCExpression>();
	for (JavacNode child : field.up().down()) {
		if (child.getKind() != Kind.FIELD) continue;
		JCVariableDecl childDecl = (JCVariableDecl) child.get();
		// Skip fields that start with $
		if (childDecl.name.toString().startsWith("$")) continue;
		long fieldFlags = childDecl.mods.flags;
		// Skip static fields.
		if ((fieldFlags & Flags.STATIC) != 0) continue;
		// Skip initialized final fields.
		if (((fieldFlags & Flags.FINAL) != 0) && childDecl.init != null) continue;
		if (child.get() == field.get()) {
			args.append(maker.Ident(fieldDecl.name));
		} else {
			args.append(createFieldAccessor(maker, child, FieldAccess.ALWAYS_FIELD));
		}
	}
	
	JCNewClass newClass = maker.NewClass(null, List.<JCExpression>nil(), selfType, args.toList(), null);
	JCExpression identityCheck = maker.Binary(CTC_EQUAL, createFieldAccessor(maker, field, FieldAccess.ALWAYS_FIELD), maker.Ident(fieldDecl.name));
	JCConditional conditional = maker.Conditional(identityCheck, maker.Ident(field.toName("this")), newClass);
	JCReturn returnStatement = maker.Return(conditional);
	
	if (nonNulls.isEmpty()) {
		statements.append(returnStatement);
	} else {
		JCStatement nullCheck = generateNullCheck(maker, field, source);
		if (nullCheck != null) statements.append(nullCheck);
		statements.append(returnStatement);
	}
	
	JCExpression returnType = cloneSelfType(field);
	
	JCBlock methodBody = maker.Block(0, statements.toList());
	List<JCTypeParameter> methodGenericParams = List.nil();
	List<JCVariableDecl> parameters = List.of(param);
	List<JCExpression> throwsClauses = List.nil();
	JCExpression annotationMethodDefaultValue = null;
	
	List<JCAnnotation> annsOnMethod = copyAnnotations(onMethod);
	
	if (isFieldDeprecated(field)) {
		annsOnMethod = annsOnMethod.prepend(maker.Annotation(genJavaLangTypeRef(field, "Deprecated"), List.<JCExpression>nil()));
	}
	JCMethodDecl decl = recursiveSetGeneratedBy(maker.MethodDef(maker.Modifiers(access, annsOnMethod), methodName, returnType,
			methodGenericParams, parameters, throwsClauses, methodBody, annotationMethodDefaultValue), source.get(), field.getContext());
	copyJavadoc(field, decl, CopyJavadoc.WITHER);
	return decl;
}
 

public JCConditional Conditional(JCExpression cond, JCExpression thenpart, JCExpression elsepart) {
	return invoke(Conditional, cond, thenpart, elsepart);
}
 

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

ConditionalType(JCExpression tree, Env<AttrContext> env, JCConditional speculativeCond, Map<ResultInfo, Type> speculativeTypes) {
   super(tree, env, speculativeCond, speculativeTypes);
}
 

ConditionalType(JCExpression tree, Env<AttrContext> env, JCConditional speculativeCond) {
    this(tree, env, speculativeCond, new HashMap<>());
}
 

@Override
public void visitConditional(JCConditional that) {
    processArg(that, speculativeTree -> new ConditionalType(that, env, speculativeTree));
}
 

@Override
public void visitConditional(JCConditional tree) {
    tree.cond.accept(this);
    tree.truepart.accept(this);
    tree.falsepart.accept(this);
}
 

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

ConditionalType(JCExpression tree, Env<AttrContext> env, JCConditional speculativeCond, Map<ResultInfo, Type> speculativeTypes) {
   super(tree, env, speculativeCond, speculativeTypes);
}
 

ConditionalType(JCExpression tree, Env<AttrContext> env, JCConditional speculativeCond) {
    this(tree, env, speculativeCond, new HashMap<>());
}
 

@Override
public void visitConditional(JCConditional that) {
    processArg(that, speculativeTree -> new ConditionalType(that, env, speculativeTree));
}