protected Collection<IEarlyExitComputer.ExitPoint> _exitPoints(final XSwitchExpression expression) { Collection<IEarlyExitComputer.ExitPoint> switchExitPoints = this.getExitPoints(expression.getSwitch()); boolean _isNotEmpty = this.isNotEmpty(switchExitPoints); if (_isNotEmpty) { EList<XCasePart> _cases = expression.getCases(); for (final XCasePart casePart : _cases) { Collection<IEarlyExitComputer.ExitPoint> defaultExit = this.getExitPoints(expression.getDefault()); boolean _isNotEmpty_1 = this.isNotEmpty(defaultExit); boolean _not = (!_isNotEmpty_1);
protected JvmTypeReference getSwitchLocalVariableType(XSwitchExpression expr) { JvmFormalParameter declaredParam = expr.getDeclaredParam(); if (declaredParam == null) { return getType(expr.getSwitch()); } return getParameterType(declaredParam); }
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 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)); }
@SuppressWarnings("null") protected void _computeTypes(XSwitchExpression object, ITypeComputationState state) { ITypeComputationState switchExpressionState = getSwitchExpressionState(object, state); ITypeComputationResult computedType = switchExpressionState.computeTypes(object.getSwitch()); JvmFormalParameter declaredParam = object.getDeclaredParam(); if (declaredParam != null) { if (declaredParam.getParameterType() == null) { uncheckedEnumLiterals = new HashSet<JvmEnumerationLiteral>(((JvmEnumerationType) potentialEnumType).getLiterals()); BranchExpressionProcessor branchExpressionProcessor = object.getDefault() == null ? new BranchExpressionProcessor(state, object) { @Override protected String getMessage() { XExpression defaultCase = object.getDefault(); if (defaultCase != null) { allCasePartsState.computeTypes(object.getDefault()); } else if (branchExpressionProcessor != null && !(isEnum && uncheckedEnumLiterals.isEmpty())) { branchExpressionProcessor.commit();
@Check public void checkDuplicatedCases(XSwitchExpression switchExpression) { LightweightTypeReference switchType = typeResolver.resolveTypes(switchExpression).getActualType(switchExpression.getSwitch()); if (switchType == null || switchType.isType(Boolean.TYPE) || switchType.isUnknown()) { return; for (XCasePart casePart : switchExpression.getCases()) { XExpression caseExpression = casePart.getCase(); if (caseExpression == null) {
/** * 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(); }
@Check public void checkTypeGuards(XCasePart casePart) { if (casePart.getTypeGuard() == null) return; LightweightTypeReference typeGuard = toLightweightTypeReference(casePart.getTypeGuard()); if (typeGuard.isPrimitive()) { error("Primitives are not allowed as type guards", Literals.XCASE_PART__TYPE_GUARD, INVALID_USE_OF_TYPE); return; } LightweightTypeReference targetTypeRef = getActualType(((XSwitchExpression) casePart.eContainer()).getSwitch()); checkCast(casePart.getTypeGuard(), typeGuard, targetTypeRef); }
if (switchExpression.getDefault() == expr) { return false;
@Check public void checkLocalUsageOfSwitchParameter(XSwitchExpression switchExpression) { JvmFormalParameter switchParam = switchExpression.getDeclaredParam(); if(!isIgnored(UNUSED_LOCAL_VARIABLE) && switchParam != null && !isLocallyUsed(switchParam, switchExpression)){ String message = "The value of the local variable " + switchParam.getName() + " is not used"; addIssue(message, switchParam, TypesPackage.Literals.JVM_FORMAL_PARAMETER__NAME, UNUSED_LOCAL_VARIABLE); } }
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); }
protected XExpression _generate(XSwitchExpression switchStatement, IAppendable it, IExtraLanguageGeneratorContext context) { final String varName; if (switchStatement.getDeclaredParam() != null) { varName = it.declareUniqueNameVariable(switchStatement.getDeclaredParam(), switchStatement.getDeclaredParam().getSimpleName()); } else { varName = it.declareSyntheticVariable(switchStatement, "___expression"); //$NON-NLS-1$ generate(switchStatement.getSwitch(), it, context); it.newLine(); boolean first = true; boolean fallThrough = false; for (final XCasePart caseExpression : switchStatement.getCases()) { if (fallThrough) { it.append(") or ("); //$NON-NLS-1$ if (switchStatement.getDefault() != null) { if (first) { generate(switchStatement.getDefault(), it, context); it.newLine(); } else { it.append("else:"); //$NON-NLS-1$ it.increaseIndentation().newLine(); generate(switchStatement.getDefault(), it, context); it.decreaseIndentation().newLine();
protected boolean allCasesAreExitedEarly(XSwitchExpression expr) { for(XCasePart casePart: expr.getCases()) { if(casePart.getThen() != null && !isEarlyExit(casePart.getThen())) { return false; } } return true; }
if (container != null && EcoreUtil.isAncestor(container.getCase(), expression)) { XSwitchExpression switchExpression = (XSwitchExpression) container.eContainer(); if (switchExpression.getSwitch() != null) { LightweightTypeReference switchVarType = batchTypeResolver.resolveTypes(expression).getActualType(switchExpression.getSwitch()); if (switchVarType != null && literal.getEnumType() == switchVarType.getType()) { return true;
protected String declareAndAppendSwitchSyntheticLocalVariable(XSwitchExpression expr, String name, ITreeAppendable b) { JvmFormalParameter declaredParam = expr.getDeclaredParam(); if (declaredParam == null) { String declareSyntheticVariable = b.declareSyntheticVariable(expr, name); b.append(declareSyntheticVariable); return declareSyntheticVariable; } String declareSyntheticVariable = b.declareSyntheticVariable(declaredParam, name); b.trace(declaredParam, TypesPackage.Literals.JVM_FORMAL_PARAMETER__NAME, 0).append(declareSyntheticVariable); return declareSyntheticVariable; }
return; if (switchExpression.getDefault() != null) { return; for (XCasePart casePart : switchExpression.getCases()) { if (!switchExpressions.isJavaCaseExpression(switchExpression, casePart)) { return; builder.append(enumerationType.getQualifiedName()); String message = builder.toString(); addIssue(message, switchExpression.getSwitch(), null, IssueCodes.INCOMPLETE_CASES_ON_ENUM, expectedEnumerationLiterals.toArray(new String[0]));
@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); } }
public LightweightTypeReference getSwitchVariableType(final XSwitchExpression it) { @Extension final IResolvedTypes resolvedTypes = this._iBatchTypeResolver.resolveTypes(it); final JvmFormalParameter declaredParam = it.getDeclaredParam(); if ((declaredParam == null)) { return resolvedTypes.getActualType(it.getSwitch()); } final LightweightTypeReference paramType = resolvedTypes.getActualType(declaredParam); LightweightTypeReference _elvis = null; if (paramType != null) { _elvis = paramType; } else { LightweightTypeReference _actualType = resolvedTypes.getActualType(it.getSwitch()); _elvis = _actualType; } return _elvis; }
/** * 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; }
protected String declareLocalVariable(XSwitchExpression expr, ITreeAppendable b) { // declare local var for the switch expression String variableName = getSwitchLocalVariableName(expr, b); if (variableName != null) { return variableName; } String name = createSwitchLocalVariableName(expr); JvmTypeReference variableType = getSwitchLocalVariableType(expr); b.newLine().append("final "); serialize(variableType, expr, b); b.append(" "); variableName = declareAndAppendSwitchSyntheticLocalVariable(expr, name, b); b.append(" = "); internalToJavaExpression(expr.getSwitch(), b); b.append(";"); return variableName; }