/** * Only for testing purpose. * @nooverride This method is not intended to be re-implemented or extended by clients. * @noreference This method is not intended to be referenced by clients. */ protected List<XCasePart> getCases(XSwitchExpression switchExpression) { return switchExpression.getCases(); }
public XExpression getThen(final XCasePart casePart, final XSwitchExpression switchExpression) { final XExpression then = casePart.getThen(); if ((then != null)) { return then; } final int casePartIndex = switchExpression.getCases().indexOf(casePart); if ((casePartIndex == (-1))) { return null; } final int count = switchExpression.getCases().size(); if ((casePartIndex == (count - 1))) { return switchExpression.getDefault(); } if (((casePartIndex + 1) < count)) { return this.getThen(switchExpression.getCases().get((casePartIndex + 1)), switchExpression); } return null; } }
protected boolean allCasesAreExitedEarly(XSwitchExpression expr) { for(XCasePart casePart: expr.getCases()) { if(casePart.getThen() != null && !isEarlyExit(casePart.getThen())) { return false; } } return true; }
/** * Determine whether the given switch expression should be compiled to a Java switch for Java version 6 or lower. */ protected boolean isCompiledToJavaSwitch(XSwitchExpression expr) { if (!switchExpressions.isJavaSwitchExpression(expr)) { return false; } for (XCasePart casePart : expr.getCases()) { if (!switchExpressions.isJavaCaseExpression(expr, casePart)) { return false; } if (!switchExpressions.isConstant(casePart)) { return false; } } return true; }
/** * Determine whether the given switch expression should be compiled to a Java switch for Java version 7 or higher. */ protected boolean isCompiledToJava7Switch(XSwitchExpression expr) { // NOTE: This method could be merged with #isCompiledToJavaSwitch(XSwitchExpression) if (!switchExpressions.isJava7SwitchExpression(expr)) { return false; } for (XCasePart casePart : expr.getCases()) { if (!switchExpressions.isJavaCaseExpression(expr, casePart)) { return false; } if (!switchExpressions.isConstant(casePart)) { return false; } } return true; }
for (XCasePart casePart : switchExpression.getCases()) { if (!switchExpressions.isJavaCaseExpression(switchExpression, casePart)) { return;
protected void _findImplicitReturns(final XSwitchExpression expression, final ImplicitReturnFinder.Acceptor acceptor) { final Consumer<XCasePart> _function = (XCasePart it) -> { this.findImplicitReturns(it.getThen(), acceptor); }; expression.getCases().forEach(_function); this.findImplicitReturns(expression.getDefault(), acceptor); }
@Check public void checkDeadCode(XSwitchExpression switchExpression) { List<XCasePart> cases = switchExpression.getCases(); for(int i = 0, size = cases.size(); i < size; i++) { XCasePart casePart = cases.get(i); XExpression caseExpression = casePart.getCase(); if (!earlyExitComputer.isEarlyExit(caseExpression)) { validateCondition(caseExpression, false); } else if (!markAsDeadCode(casePart.getThen())) { if (casePart.getTypeGuard() == null) { i = markAsDeadCode(cases, casePart, i, size); } } } }
EList<XCasePart> _cases = expression.getCases(); for (final XCasePart casePart : _cases) {
for (XCasePart casePart : switchExpression.getCases()) { XExpression caseExpression = casePart.getCase(); if (caseExpression == null) {
@Check public void checkRedundantCase(XSwitchExpression switchExpression) { XCasePart casePart = IterableExtensions.last(switchExpression.getCases()); if (casePart == null || !(casePart.isFallThrough() && casePart.getThen() == null)) { return; } if (switchExpression.getDefault() == null) { error("Redundant case.", casePart, null, IssueCodes.REDUNDANT_CASE); } else { warning("Redundant case.", casePart, null, IssueCodes.REDUNDANT_CASE); } }
@Check public void checkTypeGuardsOrder(XSwitchExpression expression) { if (isIgnored(IssueCodes.UNREACHABLE_CASE)) { return; } ITypeReferenceOwner owner = new StandardTypeReferenceOwner(getServices(), expression); List<LightweightTypeReference> previousTypeReferences = new ArrayList<LightweightTypeReference>(); for (XCasePart casePart : expression.getCases()) { JvmTypeReference typeGuard = casePart.getTypeGuard(); if (typeGuard == null) { continue; } LightweightTypeReference actualType = owner.toLightweightTypeReference(typeGuard); if (actualType == null) { continue; } if (isHandled(actualType, previousTypeReferences)) { addIssue("Unreachable code: The case can never match. It is already handled by a previous condition.", typeGuard, IssueCodes.UNREACHABLE_CASE); continue; } if (casePart.getCase() == null) { previousTypeReferences.add(actualType); } } } @Check
@Check public void checkTypeGuardsOrderWithGenerics(XSwitchExpression expression) { if (isIgnored(IssueCodes.UNREACHABLE_CASE)) { return; } ITypeReferenceOwner owner = new StandardTypeReferenceOwner(getServices(), expression); List<LightweightTypeReference> previousTypeReferences = new ArrayList<LightweightTypeReference>(); for (XCasePart casePart : expression.getCases()) { JvmTypeReference typeGuard = casePart.getTypeGuard(); if (typeGuard == null) { continue; } LightweightTypeReference typeReference = owner.toLightweightTypeReference(typeGuard); LightweightTypeReference actualType = typeReference.getRawTypeReference(); if (actualType == null || typeReference == actualType) { continue; } if (isHandled(actualType, previousTypeReferences)) { addIssue("Unreachable code: The case can never match. It is already handled by a previous condition (with the same type erasure).", typeGuard, IssueCodes.UNREACHABLE_CASE); continue; } if (casePart.getCase() == null) { previousTypeReferences.add(actualType); } } }
for (final XCasePart ex : expression.getCases()) { context.open(); if (hasSideEffects(ex.getCase(), context)) {
XSwitchExpressionCompilationState state = new XSwitchExpressionCompilationState(); List<XCasePart> fallThroughCases = Lists.newArrayList(); for (XCasePart casePart : expr.getCases()) { XExpression then = casePart.getThen(); if (then == null) {
XSwitchExpression switchExpression = (XSwitchExpression) expression; if (isDefiniteEarlyExit(switchExpression.getDefault())) { for(XCasePart caseExpression: switchExpression.getCases()) { if (!isDefiniteEarlyExit(caseExpression.getThen())) { return false;
protected Object _doEvaluate(XSwitchExpression switchExpression, IEvaluationContext context, CancelIndicator indicator) { IEvaluationContext forkedContext = context.fork(); Object conditionResult = internalEvaluate(switchExpression.getSwitch(), forkedContext, indicator); String simpleName = featureNameProvider.getSimpleName(switchExpression.getDeclaredParam()); if (simpleName != null) { forkedContext.newValue(QualifiedName.create(simpleName), conditionResult); } for (XCasePart casePart : switchExpression.getCases()) { JvmTypeReference typeGuard = casePart.getTypeGuard(); if (typeGuard != null && switchExpression.getSwitch() == null) throw new IllegalStateException("Switch without expression or implicit 'this' may not use type guards"); if (typeGuard == null || isInstanceoOf(conditionResult, typeGuard)) { if (casePart.getCase() != null) { Object casePartResult = internalEvaluate(casePart.getCase(), forkedContext, indicator); if (Boolean.TRUE.equals(casePartResult) || eq(conditionResult, casePartResult)) { XExpression then = switchExpressions.getThen(casePart, switchExpression); return internalEvaluate(then, forkedContext, indicator); } } else { XExpression then = switchExpressions.getThen(casePart, switchExpression); return internalEvaluate(then, forkedContext, indicator); } } } if (switchExpression.getDefault() != null) { Object defaultResult = internalEvaluate(switchExpression.getDefault(), forkedContext, indicator); return defaultResult; } return getDefaultObjectValue(typeResolver.resolveTypes(switchExpression).getActualType(switchExpression)); }
} else if (expression instanceof XSwitchExpression) { XSwitchExpression switchExpression = (XSwitchExpression) expression; for(XCasePart caseExpression: switchExpression.getCases()) { if (isIntentionalEarlyExit(caseExpression.getThen())) { return true;
for (XCasePart casePart : expr.getCases()) { ITreeAppendable caseAppendable = b.trace(casePart, true); caseAppendable.newLine().increaseIndentation().append("case ");
boolean first = true; boolean fallThrough = false; for (final XCasePart caseExpression : switchStatement.getCases()) { if (fallThrough) { it.append(") or ("); //$NON-NLS-1$