@Override public boolean hasSideEffects(XExpression expr) { if (expr instanceof RichString) { return false; } return super.hasSideEffects(expr); } }
public boolean isInlined(XAbstractFeatureCall call) { return findInlineAnnotation(call) != null; } }
public JvmAnnotationReference findInlineAnnotation(final JvmIdentifiableElement feature) { if (feature instanceof JvmAnnotationTarget) { return findAnnotation((JvmAnnotationTarget) feature, Inline.class.getName()); } return null; }
/** * @return whether the expression itself (not its children) possibly causes a side-effect */ public boolean hasSideEffects(XExpression expr) { if (expr instanceof XClosure || expr instanceof XStringLiteral || expr instanceof XTypeLiteral || expr instanceof XBooleanLiteral || expr instanceof XNumberLiteral || expr instanceof XNullLiteral || expr instanceof XAnnotation ) return false; if(expr instanceof XCollectionLiteral) { for(XExpression element: ((XCollectionLiteral)expr).getElements()) { if(hasSideEffects(element)) return true; } return false; } if (expr instanceof XAbstractFeatureCall) { XAbstractFeatureCall featureCall = (XAbstractFeatureCall) expr; return hasSideEffects(featureCall, true); } if (expr instanceof XConstructorCall) { XConstructorCall constrCall = (XConstructorCall) expr; return findPureAnnotation(constrCall.getConstructor()) == null; } return true; }
} else if (expressionHelper.isShortCircuitOperation(expr)) { final XBinaryOperation binaryOperation = (XBinaryOperation) expr; final XExpression leftOperand = binaryOperation.getLeftOperand(); && expressionHelper.isBooleanAndOrOr(expr) && canCompileToJavaExpression(leftOperand, b) && canCompileToJavaExpression(rightOperand, b)) { if (!expressionHelper.hasSideEffects(expr, false)) { b.append("/* "); b.append(";"); } finally { if (!expressionHelper.hasSideEffects(expr, false)) { b.append(" */");
protected Object _doEvaluate(XAbstractFeatureCall featureCall, IEvaluationContext context, CancelIndicator indicator) { if (expressionHelper.isShortCircuitOperation(featureCall)) { XExpression leftOperand = ((XBinaryOperation)featureCall).getLeftOperand(); Object result = internalEvaluate(leftOperand, context, indicator); String operatorName = featureCall.getConcreteSyntaxFeatureName(); if (equal(expressionHelper.getElvisOperator() ,operatorName)) { if(result != null) return result; } else if (equal(expressionHelper.getAndOperator(), operatorName)) { if (!(Boolean)result) return false; } else if (equal(expressionHelper.getOrOperator(), operatorName)) { if((Boolean) result) return true;
final XExpression rightOperand = binaryOperation.getRightOperand(); declareSyntheticVariable(binaryOperation, b); boolean isElvis = binaryOperation.getConcreteSyntaxFeatureName().equals(expressionHelper.getElvisOperator()); prepareExpression(leftOperand, b); if(isElvis) { } else { b.newLine().append("if ("); if (binaryOperation.getConcreteSyntaxFeatureName().equals(expressionHelper.getAndOperator())) { b.append("!"); b.append(") {").increaseIndentation(); b.newLine().append(b.getName(binaryOperation)).append(" = "); b.append(Boolean.toString(binaryOperation.getConcreteSyntaxFeatureName().equals(expressionHelper.getOrOperator()))).append(";");
public JvmAnnotationReference findCompoundAssignmentAnnotation(XAbstractFeatureCall featureCall) { final JvmIdentifiableElement feature = featureCall.getFeature(); return findReassignFirstArgumentAnnotation(feature); }
public boolean isOperatorFromExtension(XAbstractFeatureCall featureCall, String concreteSyntax, QualifiedName operatorSymbol, Class<?> definingExtensionClass) { if(!equal(concreteSyntax, operatorSymbol.getLastSegment())) return false; List<QualifiedName> methodNames = getMethodNames(featureCall, operatorSymbol); JvmDeclaredType definingJvmType = (JvmDeclaredType) typeReferences.findDeclaredType(definingExtensionClass, featureCall); if (definingJvmType == null) return false; JvmIdentifiableElement feature = featureCall.getFeature(); if (definingJvmType != feature.eContainer()) { return false; } for (QualifiedName methodName : methodNames) { if (methodName.getLastSegment().equals(feature.getSimpleName())) { return true; } } return false; }
if (findPureAnnotation(jvmOperation) == null) { return true; } else { if(inspectContents) { for (XExpression param : featureCall.getActualArguments()) { if (hasSideEffects(param)) return true;
if (operatorMapping.isCompoundMethod(methodName)) { XExpressionHelper expressionHelper = services.getExpressionHelper(); if (expressionHelper.findReassignFirstArgumentAnnotation(feature) != null) { binaryOperation.setReassignFirstArgument(true);
@Check public void checkInnerExpressions(XExpression expr) { if (!expressionHelper.hasSideEffects(expr) && !isValueExpectedRecursive(expr)) { mustBeJavaStatementExpression(expr); } }
public JvmAnnotationReference findInlineAnnotation(XAbstractFeatureCall featureCall) { final JvmIdentifiableElement feature = featureCall.getFeature(); return findInlineAnnotation(feature); }
public JvmAnnotationReference findReassignFirstArgumentAnnotation(JvmIdentifiableElement feature) { if (feature instanceof JvmAnnotationTarget) { return findAnnotation((JvmAnnotationTarget) feature, ReassignFirstArgument.class.getName()); } return null; }
protected boolean isVariableDeclarationRequired(XAbstractFeatureCall featureCall, XExpression expression, ITreeAppendable b) { if (featureCall == null) return false; XExpression actualReceiver = normalizeBlockExpression(getActualReceiver(featureCall)); List<XExpression> arguments = getActualArguments(featureCall); XExpression argument = normalizeBlockExpression(expression); int argumentIndex = -1; if (actualReceiver != argument) { argumentIndex = arguments.indexOf(argument); if (argumentIndex == -1) return false; } if (!expressionHelper.hasSideEffects(argument)) return false; int startIndex = argumentIndex + 1; int endIndex = arguments.size(); for (int i = startIndex; i < endIndex; i++) { if (isVariableDeclarationRequired(arguments.get(i), b, false)) return true; } return false; }
protected void appendInlineFeatureCall(XAbstractFeatureCall call, ITreeAppendable b) { JvmAnnotationReference inlineAnnotation = expressionHelper.findInlineAnnotation(call); String formatString = null; List<JvmTypeReference> importedTypes = Lists.newArrayListWithCapacity(2);
public JvmAnnotationReference findPureAnnotation(JvmExecutable featureCall) { return findAnnotation(featureCall, Pure.class.getName()); }
final XMemberFeatureCall sequence = getRootOfMemberFeatureCallSequence(readOnlyKeyword, null, it -> { if (getExpressionHelper().hasSideEffects(it)) { addIssue(MessageFormat.format(Messages.SARLValidator_11, keywordName), it, final JvmOperation operation = (JvmOperation) call.getFeature(); parameters = getParamTypeReferences(operation, false, true); hasSideEffects = getExpressionHelper().hasSideEffects(call); isVariadic = operation.isVarArgs(); } else {
protected synchronized void appendInlineFeatureCall(XAbstractFeatureCall call, ITreeAppendable target) { final JvmAnnotationReference inlineAnnotation = this.expressionHelper.findInlineAnnotation(call);
private void compileNullSafeFeatureCall(final XMemberFeatureCall expr, ITreeAppendable b, final boolean isReferenced) { XExpression memberCallTarget = normalizeBlockExpression(expr.getMemberCallTarget()); if (!isReferenced) { if (!expressionHelper.hasSideEffects(expr, false)) { b.append("/* "); } finally { b.decreaseIndentation().newLine().append("}"); if (!expressionHelper.hasSideEffects(expr, false)) { b.append(" */");