@Override public String apply(final XFeatureCall it) { return it.getConcreteSyntaxFeatureName(); } };
protected boolean isReferenceToSelf(XFeatureCall featureCall, JvmType type) { return !featureCall.isTypeLiteral() && !featureCall.isPackageFragment() && type.equals(featureCall.getFeature()) && IFeatureNames.SELF.getFirstSegment().equals(featureCall.getConcreteSyntaxFeatureName()); }
private boolean isEnumExpectationInAnnotationValue(final XFeatureCall it, final JvmType expectedRawType) { if (((expectedRawType instanceof JvmEnumerationType) || ((expectedRawType instanceof JvmArrayType) && (((JvmArrayType) expectedRawType).getComponentType() instanceof JvmEnumerationType)))) { EObject container = it.eContainer(); if ((container instanceof XAnnotationElementValuePair)) { return true; } if ((container instanceof XAnnotation)) { return true; } if ((container instanceof XListLiteral)) { container = ((XListLiteral)container).eContainer(); if ((container instanceof XAnnotationElementValuePair)) { return true; } if ((container instanceof XAnnotation)) { return true; } } } return false; }
protected void _visit(final XFeatureCall semanticObj, final INode originNode, final ImportsAcceptor acceptor) { if (((semanticObj.getFeature() instanceof JvmType) && semanticObj.isTypeLiteral())) { JvmIdentifiableElement _feature = semanticObj.getFeature(); this.visit(((JvmType) _feature), originNode, acceptor); } else { this.collectStaticImportsFrom(semanticObj, acceptor); } }
@Check public void checkExplicitOperationCall(XFeatureCall featureCall) { if (featureCall.getFeature() instanceof JvmOperation && !featureCall.isExplicitOperationCallOrBuilderSyntax() && featureCall.getFeature().getSimpleName().equals(featureCall.getConcreteSyntaxFeatureName())) { addIssue("Method call without parentheses", featureCall, XbasePackage.Literals.XABSTRACT_FEATURE_CALL__FEATURE, OPERATION_WITHOUT_PARENTHESES); } }
protected boolean isSimpleFeatureCall(XExpression switch1) { if (switch1 instanceof XFeatureCall) { XFeatureCall featureCall = (XFeatureCall) switch1; return !(featureCall.getFeature() instanceof JvmOperation); } return false; }
protected boolean hasConstructorCallWithThis(JvmConstructor constr) { XExpression associatedExpression = logicalContainerProvider.getAssociatedExpression(constr); if (associatedExpression == null) { return false; } TreeIterator<EObject> contents = associatedExpression.eAllContents(); while (contents.hasNext()) { EObject next = contents.next(); if (next instanceof XFeatureCall) { XFeatureCall featureCall = (XFeatureCall) next; if (featureCall.getFeature() instanceof JvmConstructor && featureCall.getConcreteSyntaxFeatureName().equals(IFeatureNames.THIS.toString())) { return true; } } } return false; }
protected IFeatureScopeSession addExtensionsToMemberSession(ResolvedTypes resolvedTypes, IFeatureScopeSession featureScopeSession, JvmDeclaredType type) { IEObjectDescription thisDescription = featureScopeSession.getLocalElement(IFeatureNames.THIS); if (thisDescription == null) { throw new IllegalStateException("Cannot find feature 'THIS'"); } JvmIdentifiableElement thisFeature = (JvmIdentifiableElement) thisDescription.getEObjectOrProxy(); IFeatureScopeSession childSession = addExtensionFieldsToMemberSession( resolvedTypes, featureScopeSession, type, thisFeature, Sets.<String>newHashSetWithExpectedSize(8), Sets.<JvmType>newHashSetWithExpectedSize(4)); XFeatureCall thisAccess = getXbaseFactory().createXFeatureCall(); thisAccess.setFeature(thisFeature); LightweightTypeReference thisType = resolvedTypes.getActualType(thisFeature); childSession = childSession.addToExtensionScope(Collections.<XExpression, LightweightTypeReference>singletonMap(thisAccess, thisType)); return childSession; }
List<JvmTypeReference> typeArguments = featureCall.getTypeArguments(); if (!typeArguments.isEmpty()) { acceptor.accept(featureCallElements.getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_0(), typeArguments.get(0), 0); acceptor.accept(featureCallElements.getFeatureJvmIdentifiableElementIdOrSuperParserRuleCall_2_0_1(), featureCall.getFeature()); if (featureCall.isExplicitOperationCallOrBuilderSyntax()) { if (featureCall.isExplicitOperationCall()) acceptor.accept(featureCallElements.getExplicitOperationCallLeftParenthesisKeyword_3_0_0()); List<XExpression> arguments = featureCall.getFeatureCallArguments(); if (!arguments.isEmpty()) { if (featureCall.isExplicitOperationCall() && isXShortClosureAndBuilderSyntax(arguments, XbasePackage.Literals.XFEATURE_CALL__FEATURE_CALL_ARGUMENTS, nodes)) { acceptor.accept(featureCallElements.getFeatureCallArgumentsXShortClosureParserRuleCall_3_1_0_0(), arguments.get(0), 0); acceptor.accept(featureCallElements.getFeatureCallArgumentsXClosureParserRuleCall_4_0(), arguments.get(1), 1); } else if (featureCall.isExplicitOperationCall() && isXShortClosure(featureCall, XbasePackage.Literals.XFEATURE_CALL__FEATURE_CALL_ARGUMENTS, nodes)) { acceptor.accept(featureCallElements.getFeatureCallArgumentsXShortClosureParserRuleCall_3_1_0_0(), arguments.get(0), 0); } else { int diff = 0; if (isBuilderSyntax(featureCall, XbasePackage.Literals.XFEATURE_CALL__FEATURE_CALL_ARGUMENTS, featureCall.isExplicitOperationCall(), nodes)) { diff = 1; if (featureCall.isExplicitOperationCall()) { if (arguments.size() - diff > 0) acceptor.accept(featureCallElements.getFeatureCallArgumentsXExpressionParserRuleCall_3_1_1_0_0(), arguments.get(0), 0);
protected Object _internalEvaluate(final XFeatureCall it, final Context ctx) { Object _eGet = it.eGet(XbasePackage.Literals.XABSTRACT_FEATURE_CALL__FEATURE, this.isResolveProxies(it)); final EObject feature = ((EObject) _eGet); boolean _eIsProxy = feature.eIsProxy(); final String featureName = it.getConcreteSyntaxFeatureName(); JvmType _switchResult_1 = null; JvmTypeReference _expectedType = ctx.getExpectedType();
call.setFeature(getJvmConstructor(constructor, context)); call.setExplicitOperationCall(true); final List<XExpression> arguments = call.getFeatureCallArguments(); for (final IFormalParameterBuilder currentParam : sarlParams) { final XFeatureCall argumentSource = XbaseFactory.eINSTANCE.createXFeatureCall();
@Check public void checkConstructorArgumentsAreValid(XFeatureCall featureCall) { JvmIdentifiableElement feature = featureCall.getFeature(); if (feature != null && !feature.eIsProxy() && feature instanceof JvmConstructor) { JvmType containerType = EcoreUtil2.getContainerOfType(logicalContainerProvider.getNearestLogicalContainer(featureCall), JvmType.class); for(XExpression argument: featureCall.getFeatureCallArguments()) { checkIsValidConstructorArgument(argument, containerType); } } }
protected void _format(final XFeatureCall expr, final FormattableDocument format) { this.formatFeatureCallTypeParameters(expr, format); boolean _isExplicitOperationCall = expr.isExplicitOperationCall(); if (_isExplicitOperationCall) { final ILeafNode open = this._nodeModelAccess.nodeForKeyword(expr, "("); final Procedure1<FormattingDataInit> _function = (FormattingDataInit it) -> { it.noSpace(); }; Function1<? super FormattableDocument, ? extends Iterable<FormattingData>> _prepend = this._formattingDataFactory.prepend(open, _function); format.operator_add(_prepend); boolean _isMultiParamInOwnLine = this.isMultiParamInOwnLine(expr, format); if (_isMultiParamInOwnLine) { this.formatFeatureCallParamsMultiline(open, expr.getFeatureCallArguments(), format); } else { this.formatFeatureCallParamsWrapIfNeeded(open, expr.getFeatureCallArguments(), format); } } else { EList<XExpression> _featureCallArguments = expr.getFeatureCallArguments(); for (final XExpression arg : _featureCallArguments) { this.format(arg, format); } } }
/** * Returns the node that best describes the error, e.g. if there is an expression * <code>com::foo::DoesNotExist::method()</code> the error will be rooted at <code>com</code>, but * the real problem is <code>com::foo::DoesNotExist</code>. */ private INode getErrorNode(XExpression expression, INode node) { if (expression instanceof XFeatureCall) { XFeatureCall featureCall = (XFeatureCall) expression; if (!canBeTypeLiteral(featureCall)) { return node; } if (featureCall.eContainingFeature() == XbasePackage.Literals.XMEMBER_FEATURE_CALL__MEMBER_CALL_TARGET) { XMemberFeatureCall container = (XMemberFeatureCall) featureCall.eContainer(); if (canBeTypeLiteral(container)) { boolean explicitStatic = container.isExplicitStatic(); XMemberFeatureCall outerMost = getLongestTypeLiteralCandidate(container, explicitStatic); if (outerMost != null) return NodeModelUtils.getNode(outerMost); } } } return node; }
public List<XExpression> getSyntacticArguments(XAbstractFeatureCall expression) { if (expression instanceof XFeatureCall) { return ((XFeatureCall) expression).getFeatureCallArguments(); } if (expression instanceof XMemberFeatureCall) { return ((XMemberFeatureCall) expression).getMemberCallArguments(); } if (expression instanceof XAssignment) { return Collections.singletonList(((XAssignment) expression).getValue()); } if (expression instanceof XBinaryOperation) { return Collections.singletonList(((XBinaryOperation) expression).getRightOperand()); } // explicit condition to make sure we thought about it if (expression instanceof XUnaryOperation) { return Collections.emptyList(); } if (expression instanceof XPostfixOperation) { return Collections.emptyList(); } return Collections.emptyList(); }
protected boolean isDelegateConstructorCall(XExpression expression) { if(expression instanceof XFeatureCall) { JvmIdentifiableElement feature = ((XFeatureCall)expression).getFeature(); return (feature != null && !feature.eIsProxy() && feature instanceof JvmConstructor); } return false; }
@Override public void addExtensionsToCurrentScope(List<? extends JvmIdentifiableElement> extensionProviders) { if (extensionProviders.isEmpty()) return; if (extensionProviders.size() == 1) { addExtensionToCurrentScope(extensionProviders.get(0)); return; } Map<XExpression, LightweightTypeReference> prototypeToType = Maps2.newLinkedHashMapWithExpectedSize(extensionProviders.size()); for(JvmIdentifiableElement extensionProvider: extensionProviders) { LightweightTypeReference knownType = getResolvedTypes().getActualType(extensionProvider); if (knownType != null && !knownType.isAny() && !knownType.isUnknown()) { XFeatureCall prototype = getResolver().getXbaseFactory().createXFeatureCall(); prototype.setFeature(extensionProvider); prototypeToType.put(prototype, knownType); } } if (!prototypeToType.isEmpty()) featureScopeSession = featureScopeSession.addToExtensionScope(prototypeToType); }
protected Object _doEvaluate(XFeatureCall featureCall, IEvaluationContext context, CancelIndicator indicator) { if (featureCall.isTypeLiteral()) { JvmType type = (JvmType) featureCall.getFeature(); Object result = translateJvmTypeToResult(type, 0); return result; } else { return _doEvaluate((XAbstractFeatureCall) featureCall, context, indicator); } }
protected void _format(final XFeatureCall expr, @Extension final IFormattableDocument format) { this.formatFeatureCallTypeParameters(expr, format); boolean _isExplicitOperationCall = expr.isExplicitOperationCall(); if (_isExplicitOperationCall) { final Procedure1<IHiddenRegionFormatter> _function = (IHiddenRegionFormatter it) -> { it.noSpace(); }; final ISemanticRegion open = format.prepend(this.textRegionExtensions.regionFor(expr).keyword(this.grammar.getXFeatureCallAccess().getExplicitOperationCallLeftParenthesisKeyword_3_0_0()), _function); final ISemanticRegion close = this.textRegionExtensions.regionFor(expr).keyword(this.grammar.getXFeatureCallAccess().getRightParenthesisKeyword_3_2()); this.formatFeatureCallParams(expr.getFeatureCallArguments(), open, close, format); } else { EList<XExpression> _featureCallArguments = expr.getFeatureCallArguments(); for (final XExpression arg : _featureCallArguments) { this.format(arg, format); } } }
protected boolean _isMultiParamInOwnLine(final XFeatureCall fc, final FormattableDocument doc) { final ILeafNode closingBracket = this._nodeModelAccess.nodeForKeyword(fc, ")"); HiddenLeafs _hiddenLeafsBefore = null; if (closingBracket!=null) { _hiddenLeafsBefore=this._hiddenLeafAccess.getHiddenLeafsBefore(closingBracket); } boolean _tripleNotEquals = (_hiddenLeafsBefore != null); if (_tripleNotEquals) { int _newLines = this._hiddenLeafAccess.getHiddenLeafsBefore(closingBracket).getNewLines(); return (_newLines > 0); } final Iterable<XExpression> params = this.explicitParams(fc.getFeatureCallArguments()); return ((IterableExtensions.size(params) > 1) && this.isEachExpressionInOwnLine(params)); }