protected List<XExpression> getActualArguments(XAbstractFeatureCall featureCall) { return featureCall.getActualArguments(); }
protected List<XExpression> getActualArguments(final XAbstractFeatureCall expr) { List<XExpression> actualArguments = expr.getActualArguments(); return Lists.transform(actualArguments, new Function<XExpression, XExpression>() { @Override public XExpression apply(XExpression e) { return normalizeBlockExpression(e); } }); }
@Override protected List<XExpression> getActualArguments(XAbstractFeatureCall featureCall) { EList<XExpression> actualArguments = featureCall.getActualArguments(); List<XExpression> normalizedArguments = normalizeBlockExpression(actualArguments); return normalizedArguments; }
public String arguments(XAbstractFeatureCall featureCall) { List<XExpression> arguments = featureCall.getActualArguments(); return "(" + expressionTypes(arguments) + ")"; }
@Override protected List<XExpression> getArguments() { return getFeatureCall().getActualArguments(); }
private List<XExpression> getActualArguments(XAbstractFeatureCall expr) { final List<XExpression> actualArguments = expr.getActualArguments(); return Lists.transform(actualArguments, it -> normalizeBlockExpression(it)); }
protected Collection<IEarlyExitComputer.ExitPoint> _exitPoints(final XAbstractFeatureCall expression) { EList<XExpression> _actualArguments = expression.getActualArguments(); for (final XExpression argument : _actualArguments) { { Collection<IEarlyExitComputer.ExitPoint> argumentExitPoints = this.getExitPoints(argument); boolean _isNotEmpty = this.isNotEmpty(argumentExitPoints); if (_isNotEmpty) { return argumentExitPoints; } } } return Collections.<IEarlyExitComputer.ExitPoint>emptyList(); }
private static boolean hasLocalParameters(EObject current, XExpression container, List<JvmFormalParameter> containerParameters) { if (current instanceof XAbstractFeatureCall) { final XAbstractFeatureCall featureCall = (XAbstractFeatureCall) current; if (isLocalEntity(featureCall, container, containerParameters)) { return true; } for (final XExpression argument : featureCall.getActualArguments()) { final Iterable<XAbstractFeatureCall> iterable; if (argument instanceof XAbstractFeatureCall) { iterable = Iterables.concat( Collections.singletonList((XAbstractFeatureCall) argument), EcoreUtil2.getAllContentsOfType(argument, XAbstractFeatureCall.class)); } else { iterable = EcoreUtil2.getAllContentsOfType(argument, XAbstractFeatureCall.class); } for (final XAbstractFeatureCall c : iterable) { if (isLocalEntity(c, container, containerParameters)) { return true; } } } } return false; }
protected Object evaluateGetAndAssign(XAbstractFeatureCall featureCall, IEvaluationContext context, CancelIndicator indicator) { XAbstractFeatureCall operand = (XAbstractFeatureCall) featureCall.getActualArguments().get(0); Object originalValue = internalEvaluate(operand, context, indicator); Object value = applyGetAndAssignOperator(originalValue, featureCall.getConcreteSyntaxFeatureName()); assignValueTo(operand.getFeature(), featureCall, value, context, indicator); return originalValue; }
private boolean isPotentialJavaOperation(XAbstractFeatureCall featureCall) { if (featureCall.isOperation()) { return true; } if (featureCall.eClass() == XbasePackage.Literals.XMEMBER_FEATURE_CALL && featureCall.isStatic() && featureCall.isExtension() && featureCall.getActualArguments().size() == 2) { JvmIdentifiableElement feature = featureCall.getFeature(); if (feature.eClass() == TypesPackage.Literals.JVM_OPERATION) { JvmDeclaredType declarator = ((JvmOperation) feature).getDeclaringType(); if (IntegerExtensions.class.getName().equals(declarator.getIdentifier()) || LongExtensions.class.getName().equals(declarator.getIdentifier())) { String simpleName = feature.getSimpleName(); if (simpleName.startsWith("bitwise") || simpleName.startsWith("shift")) { return true; } } } } return false; }
} else { if(inspectContents) { for (XExpression param : featureCall.getActualArguments()) { if (hasSideEffects(param)) return true;
return false; for (XExpression arg : featureCall.getActualArguments()) { if (!this.internalCanCompileToJavaExpression(arg, appendable)) { return false;
return (receiverConstant && IterableExtensions.<XExpression>forall(expression.getActualArguments(), ((Function1<XExpression, Boolean>) (XExpression it) -> { return Boolean.valueOf(this.isConstant(it)); })));
final XAbstractFeatureCall call = (XAbstractFeatureCall) container.get(); if (call.getFeature() instanceof JvmOperation) { arguments = call.getActualArguments(); final JvmOperation operation = (JvmOperation) call.getFeature(); parameters = getParamTypeReferences(operation, false, true);
for (final XExpression ex : expression.getActualArguments()) { final Boolean bool = hasSideEffects(ex, context); if (bool != null && bool.booleanValue()) {
if (inlineAnnotation == null) return true; for (XExpression argument : featureCall.getActualArguments()) { if (isVariableDeclarationRequired(argument, b, recursive)) { return true;