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

public void visitSwitch(JCSwitch tree) {
    ListBuffer<PendingExit> prevPendingExits = pendingExits;
    pendingExits = new ListBuffer<>();
    scan(tree.selector);
    boolean hasDefault = false;
    for (List<JCCase> l = tree.cases; l.nonEmpty(); l = l.tail) {
        alive = true;
        JCCase c = l.head;
        if (c.pat == null)
            hasDefault = true;
        else
            scan(c.pat);
        scanStats(c.stats);
        // Warn about fall-through if lint switch fallthrough enabled.
        if (alive &&
            lint.isEnabled(Lint.LintCategory.FALLTHROUGH) &&
            c.stats.nonEmpty() && l.tail.nonEmpty())
            log.warning(Lint.LintCategory.FALLTHROUGH,
                        l.tail.head.pos(),
                        Warnings.PossibleFallThroughIntoCase);
    }
    if (!hasDefault) {
        alive = true;
    }
    alive |= resolveBreaks(tree, prevPendingExits);
}
 

public void visitCase(JCCase tree) {
	try {
		if (tree.pat == null) {
			print("default");
		} else {
			print("case ");
			printExpr(tree.pat);
		}
		print(": ");
		println();
		indent();
		printStats(tree.stats);
		undent();
		align();
	} catch (IOException e) {
		throw new UncheckedIOException(e);
	}
}
 

/**  Visitor method: compute source positions for
 *    a list of case blocks of switch statements.
 */
public SourceRange cspCases(List<JCCase> trees) {
    if ((trees == null) || !(trees.nonEmpty())) return null;
    SourceRange list_sr = new SourceRange();
    for (List<JCCase> l = trees; l.nonEmpty(); l = l.tail) {
        list_sr.mergeWith(csp(l.head));
    }
    positions.put(trees, list_sr);
    return list_sr;
}
 

public void visitSwitch(JCSwitch tree) {
    ListBuffer<FlowPendingExit> prevPendingExits = pendingExits;
    pendingExits = new ListBuffer<>();
    scan(tree.selector);
    for (List<JCCase> l = tree.cases; l.nonEmpty(); l = l.tail) {
        JCCase c = l.head;
        if (c.pat != null) {
            scan(c.pat);
        }
        scan(c.stats);
    }
    resolveBreaks(tree, prevPendingExits);
}
 

public void visitSwitch(JCSwitch tree) {
    ListBuffer<AssignPendingExit> prevPendingExits = pendingExits;
    pendingExits = new ListBuffer<>();
    int nextadrPrev = nextadr;
    scanExpr(tree.selector);
    final Bits initsSwitch = new Bits(inits);
    final Bits uninitsSwitch = new Bits(uninits);
    boolean hasDefault = false;
    for (List<JCCase> l = tree.cases; l.nonEmpty(); l = l.tail) {
        inits.assign(initsSwitch);
        uninits.assign(uninits.andSet(uninitsSwitch));
        JCCase c = l.head;
        if (c.pat == null) {
            hasDefault = true;
        } else {
            scanExpr(c.pat);
        }
        if (hasDefault) {
            inits.assign(initsSwitch);
            uninits.assign(uninits.andSet(uninitsSwitch));
        }
        scan(c.stats);
        addVars(c.stats, initsSwitch, uninitsSwitch);
        if (!hasDefault) {
            inits.assign(initsSwitch);
            uninits.assign(uninits.andSet(uninitsSwitch));
        }
        // Warn about fall-through if lint switch fallthrough enabled.
    }
    if (!hasDefault) {
        inits.andSet(initsSwitch);
    }
    resolveBreaks(tree, prevPendingExits);
    nextadr = nextadrPrev;
}
 

public void visitCase(JCCase tree) {
    SourceRange sr = new SourceRange(startPos(tree), endPos(tree));
    sr.mergeWith(csp(tree.pat));
    sr.mergeWith(csp(tree.stats));
    result = sr;
}
 

public void visitCase(JCCase tree) {
    tree.pat = translate(tree.pat, null);
    tree.stats = translate(tree.stats);
    result = tree;
}
 

public JCSwitch Switch(JCExpression selector, List<JCCase> cases) {
	return invoke(Switch, selector, cases);
}
 

public JCCase Case(JCExpression pat, List<JCStatement> stats) {
	return invoke(Case, pat, stats);
}
 

@Override public void handle(AnnotationValues<Cleanup> annotation, JCAnnotation ast, JavacNode annotationNode) {
	handleFlagUsage(annotationNode, ConfigurationKeys.CLEANUP_FLAG_USAGE, "@Cleanup");
	
	if (inNetbeansEditor(annotationNode)) return;
	
	deleteAnnotationIfNeccessary(annotationNode, Cleanup.class);
	String cleanupName = annotation.getInstance().value();
	if (cleanupName.length() == 0) {
		annotationNode.addError("cleanupName cannot be the empty string.");
		return;
	}
	
	if (annotationNode.up().getKind() != Kind.LOCAL) {
		annotationNode.addError("@Cleanup is legal only on local variable declarations.");
		return;
	}
	
	JCVariableDecl decl = (JCVariableDecl)annotationNode.up().get();
	
	if (decl.init == null) {
		annotationNode.addError("@Cleanup variable declarations need to be initialized.");
		return;
	}
	
	JavacNode ancestor = annotationNode.up().directUp();
	JCTree blockNode = ancestor.get();
	
	final List<JCStatement> statements;
	if (blockNode instanceof JCBlock) {
		statements = ((JCBlock)blockNode).stats;
	} else if (blockNode instanceof JCCase) {
		statements = ((JCCase)blockNode).stats;
	} else if (blockNode instanceof JCMethodDecl) {
		statements = ((JCMethodDecl)blockNode).body.stats;
	} else {
		annotationNode.addError("@Cleanup is legal only on a local variable declaration inside a block.");
		return;
	}
	
	boolean seenDeclaration = false;
	ListBuffer<JCStatement> newStatements = new ListBuffer<JCStatement>();
	ListBuffer<JCStatement> tryBlock = new ListBuffer<JCStatement>();
	for (JCStatement statement : statements) {
		if (!seenDeclaration) {
			if (statement == decl) seenDeclaration = true;
			newStatements.append(statement);
		} else {
			tryBlock.append(statement);
		}
	}
	
	if (!seenDeclaration) {
		annotationNode.addError("LOMBOK BUG: Can't find this local variable declaration inside its parent.");
		return;
	}
	doAssignmentCheck(annotationNode, tryBlock.toList(), decl.name);
	
	JavacTreeMaker maker = annotationNode.getTreeMaker();
	JCFieldAccess cleanupMethod = maker.Select(maker.Ident(decl.name), annotationNode.toName(cleanupName));
	List<JCStatement> cleanupCall = List.<JCStatement>of(maker.Exec(
			maker.Apply(List.<JCExpression>nil(), cleanupMethod, List.<JCExpression>nil())));
	
	JCExpression preventNullAnalysis = preventNullAnalysis(maker, annotationNode, maker.Ident(decl.name));
	JCBinary isNull = maker.Binary(CTC_NOT_EQUAL, preventNullAnalysis, maker.Literal(CTC_BOT, null));
	
	JCIf ifNotNullCleanup = maker.If(isNull, maker.Block(0, cleanupCall), null);
	
	Context context = annotationNode.getContext();
	JCBlock finalizer = recursiveSetGeneratedBy(maker.Block(0, List.<JCStatement>of(ifNotNullCleanup)), ast, context);
	
	newStatements.append(setGeneratedBy(maker.Try(setGeneratedBy(maker.Block(0, tryBlock.toList()), ast, context), List.<JCCatch>nil(), finalizer), ast, context));
	
	if (blockNode instanceof JCBlock) {
		((JCBlock)blockNode).stats = newStatements.toList();
	} else if (blockNode instanceof JCCase) {
		((JCCase)blockNode).stats = newStatements.toList();
	} else if (blockNode instanceof JCMethodDecl) {
		((JCMethodDecl)blockNode).body.stats = newStatements.toList();
	} else throw new AssertionError("Should not get here");
	
	ancestor.rebuild();
}