protected void _visit(final XMemberFeatureCall semanticObj, final INode originNode, final ImportsAcceptor acceptor) { if (((semanticObj.getFeature() instanceof JvmType) && semanticObj.isTypeLiteral())) { JvmIdentifiableElement _feature = semanticObj.getFeature(); this.visit(((JvmType) _feature), originNode, acceptor); } boolean _isExplicitStatic = semanticObj.isExplicitStatic(); boolean _not = (!_isExplicitStatic); if (_not) { final XExpression target = semanticObj.getMemberCallTarget(); if ((target instanceof XAbstractFeatureCall)) { boolean _isTypeLiteral = ((XAbstractFeatureCall)target).isTypeLiteral(); if (_isTypeLiteral) { return; } } this.collectStaticImportsFrom(semanticObj, acceptor); } }
protected String _getFullName(final XMemberFeatureCall call) { final String prefix = this.getFullName(call.getMemberCallTarget()); String _concreteSyntaxFeatureName = call.getConcreteSyntaxFeatureName(); return ((prefix + ".") + _concreteSyntaxFeatureName); }
@Override protected ITextRegion getLocationOfContainmentReference(EObject owner, EReference reference, int indexInList, RegionDescription query) { if (owner instanceof XMemberFeatureCall && reference == XbasePackage.Literals.XMEMBER_FEATURE_CALL__MEMBER_CALL_TARGET) { XMemberFeatureCall casted = (XMemberFeatureCall) owner; if (casted.isExplicitStatic() || casted.isStaticWithDeclaringType()) { XExpression target = ((XMemberFeatureCall) owner).getMemberCallTarget(); return getTextRegion(target, query); } } return super.getLocationOfContainmentReference(owner, reference, indexInList, query); }
protected XAbstractFeatureCall doGetRootTypeLiteral(XMemberFeatureCall featureCall) { boolean staticNotation = featureCall.isExplicitStatic(); XMemberFeatureCall current = featureCall; while(current.eContainingFeature() == XbasePackage.Literals.XMEMBER_FEATURE_CALL__MEMBER_CALL_TARGET) { XMemberFeatureCall container = (XMemberFeatureCall) current.eContainer(); if (container.isExplicitStatic()) { if (staticNotation == false) { return current; } current = container; } else if (staticNotation) { return (XAbstractFeatureCall) current.getMemberCallTarget(); } else { current = container; } } if (current != featureCall && staticNotation) { return (XAbstractFeatureCall) current.getMemberCallTarget(); } return null; }
acceptor.accept(memberFeatureCallElements.getXMemberFeatureCallMemberCallTargetAction_1_1_0_0_0(), featureCall.getMemberCallTarget()); if (featureCall.isNullSafe()) acceptor.accept(memberFeatureCallElements.getNullSafeQuestionMarkFullStopKeyword_1_1_0_0_1_1_0()); else if (featureCall.isExplicitStatic()) acceptor.accept(memberFeatureCallElements.getExplicitStaticColonColonKeyword_1_1_0_0_1_2_0()); List<JvmTypeReference> typeArguments = featureCall.getTypeArguments(); if (!typeArguments.isEmpty()) { acceptor.accept(memberFeatureCallElements.getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_1_1_0(), typeArguments.get(0), 0); acceptor.accept(memberFeatureCallElements.getFeatureJvmIdentifiableElementIdOrSuperParserRuleCall_1_1_2_0_1(), featureCall.getFeature()); if (featureCall.isExplicitOperationCallOrBuilderSyntax()) { if (featureCall.isExplicitOperationCall()) acceptor.accept(memberFeatureCallElements.getExplicitOperationCallLeftParenthesisKeyword_1_1_3_0_0()); List<XExpression> arguments = featureCall.getMemberCallArguments(); if (!arguments.isEmpty()) { if (featureCall.isExplicitOperationCall() && isXShortClosureAndBuilderSyntax(arguments, XbasePackage.Literals.XFEATURE_CALL__FEATURE_CALL_ARGUMENTS, nodes)) { acceptor.accept(memberFeatureCallElements.getMemberCallArgumentsXShortClosureParserRuleCall_1_1_3_1_0_0(), arguments.get(0), 0); acceptor.accept(memberFeatureCallElements.getMemberCallArgumentsXClosureParserRuleCall_1_1_4_0(), arguments.get(1), 1); } else if (featureCall.isExplicitOperationCall() && isXShortClosure(featureCall, XbasePackage.Literals.XMEMBER_FEATURE_CALL__MEMBER_CALL_ARGUMENTS, nodes)) { acceptor.accept(memberFeatureCallElements.getMemberCallArgumentsXShortClosureParserRuleCall_1_1_3_1_0_0(), arguments.get(0), 0); } else { int diff = 0; if (isBuilderSyntax(featureCall, XbasePackage.Literals.XMEMBER_FEATURE_CALL__MEMBER_CALL_ARGUMENTS, featureCall.isExplicitOperationCall(), nodes)) { diff = 1; if (featureCall.isExplicitOperationCall()) {
private int countSegments(XMemberFeatureCall call) { int result = 1; while(call.getMemberCallTarget() instanceof XMemberFeatureCall) { call = (XMemberFeatureCall) call.getMemberCallTarget(); result++; } return result; }
final XMemberFeatureCall it = ((XMemberFeatureCall)top); boolean _matched = false; boolean _isNullSafe = it.isNullSafe(); if (_isNullSafe) { _matched=true; boolean _isExplicitStatic = it.isExplicitStatic(); if (_isExplicitStatic) { _matched=true; final ISemanticRegion separator = this.textRegionExtensions.regionFor(top).keyword(op); calls.prependWithLeadingSeparator(((XMemberFeatureCall)top), separator); top = ((XMemberFeatureCall)top).getMemberCallTarget(); }; format.append(format.prepend(operator, _function), _function_1); boolean _isExplicitOperationCall = call.isExplicitOperationCall(); if (_isExplicitOperationCall) { final Procedure1<IHiddenRegionFormatter> _function_2 = (IHiddenRegionFormatter it) -> { final ISemanticRegion open = format.prepend(this.textRegionExtensions.regionFor(call).keyword(this.grammar.getXMemberFeatureCallAccess().getExplicitOperationCallLeftParenthesisKeyword_1_1_3_0_0()), _function_2); final ISemanticRegion close = this.textRegionExtensions.regionFor(call).keyword(this.grammar.getXMemberFeatureCallAccess().getRightParenthesisKeyword_1_1_3_2()); this.formatFeatureCallParams(call.getMemberCallArguments(), open, close, format); } else { boolean _isEmpty = call.getMemberCallArguments().isEmpty(); boolean _not = (!_isEmpty); if (_not) { this.formatBuilderWithLeadingGap(this.builder(call.getMemberCallArguments()), format);
@Check public void checkExplicitOperationCall(XMemberFeatureCall 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); } }
if ((((((XMemberFeatureCall)expression).getFeature() != null) && ((XMemberFeatureCall)expression).getFeature().eIsProxy()) && (!((XMemberFeatureCall)expression).isExplicitOperationCallOrBuilderSyntax()))) { _matched=true; final XExpression receiver = ((XMemberFeatureCall)expression).getActualReceiver(); boolean _matched_1 = false; if (receiver instanceof XAbstractFeatureCall) { String _identifier = type.getIdentifier(); String _plus = (_identifier + "$"); String _concreteSyntaxFeatureName = ((XMemberFeatureCall)expression).getConcreteSyntaxFeatureName(); String _plus_1 = (_plus + _concreteSyntaxFeatureName); QualifiedName _lowerCase = this.nameConverter.toQualifiedName(_plus_1).toLowerCase();
@Check void checkNullSafeFeatureCallWithPrimitives(XMemberFeatureCall featureCall) { if (featureCall.isNullSafe()) { if (getActualType(featureCall.getMemberCallTarget()).isPrimitive()) { error("Cannot use null-safe feature call on primitive receiver", featureCall, Literals.XMEMBER_FEATURE_CALL__NULL_SAFE, NULL_SAFE_FEATURE_CALL_ON_PRIMITIVE); return; } LightweightTypeReference type = getActualType(featureCall); if (type.isPrimitive() && isValueExpectedRecursive(featureCall)) { addIssue("Null-safe call of primitive-valued feature " + featureCall.getConcreteSyntaxFeatureName() + ", default value "+ getDefaultValue(type) +" will be used", featureCall, NULL_SAFE_FEATURE_CALL_OF_PRIMITIVE_VALUED_FEATURE); } } }
private static void loopReceiver(LinkedList<String> sourceFeature, Object obj) { if (obj instanceof XMemberFeatureCall) { final XMemberFeatureCall memberFeatureCall = (XMemberFeatureCall) obj; sourceFeature.addFirst(memberFeatureCall.getFeature().getSimpleName()); loopReceiver(sourceFeature, memberFeatureCall.getMemberCallTarget()); } else if (obj instanceof XFeatureCall) { final XFeatureCall featureCall = (XFeatureCall) obj; sourceFeature.addFirst(featureCall.getFeature().getIdentifier()); } }
protected boolean isPotentialTypeLiteralImpl(XExpression featureCall, /* @Nullable */ IResolvedTypes resolvedTypes, boolean staticNotation) { if (featureCall instanceof XMemberFeatureCall) { XMemberFeatureCall casted = (XMemberFeatureCall) featureCall; if (casted.isExplicitOperationCallOrBuilderSyntax() || casted.isNullSafe()) { return false; } XExpression target = casted.getMemberCallTarget(); if (casted.isExplicitStatic() != staticNotation) { return false; } return isPotentialTypeLiteralImpl(target, resolvedTypes, staticNotation); } if (featureCall instanceof XFeatureCall) { XFeatureCall casted = (XFeatureCall) featureCall; if (casted.isExplicitOperationCallOrBuilderSyntax()) { return false; } if (resolvedTypes == null) return true; LightweightTypeReference knownType = resolvedTypes.getActualType(casted); if (knownType == null || knownType.isUnknown()) { return true; } } return false; }
if (call instanceof XMemberFeatureCall) { final XMemberFeatureCall memberFeatureCall = (XMemberFeatureCall) call; if (memberFeatureCall.isStaticWithDeclaringType()) { final XAbstractFeatureCall target = (XAbstractFeatureCall) memberFeatureCall.getMemberCallTarget(); final JvmType declaringType = (JvmType) target.getFeature(); output.add(declaringType);
protected Object _internalEvaluate(final XMemberFeatureCall 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(); try { final Object receiver = this.evaluate(it.getMemberCallTarget(), ctx); boolean _matched_1 = false; if (receiver instanceof JvmTypeReference) {
protected Object _doEvaluate(final XMemberFeatureCall featureCall, final IEvaluationContext context, final CancelIndicator indicator) { if (featureCall.isTypeLiteral()) { JvmType type = (JvmType) featureCall.getFeature(); Object result = translateJvmTypeToResult(type, 0); return result; } else { XExpression receiver = getActualReceiver(featureCall); //, featureCall.getFeature(), featureCall.getImplicitReceiver()); Object receiverObj = receiver==null?null:internalEvaluate(receiver, context, indicator); if (featureCall.isNullSafe() && receiverObj==null) { return getDefaultObjectValue(typeResolver.resolveTypes(featureCall).getActualType(featureCall)); } return invokeFeature(featureCall.getFeature(), featureCall, receiverObj, context, indicator); } }
protected XAbstractFeatureCall createExtensionProvider(JvmIdentifiableElement thisFeature, JvmField field) { if (field.isStatic()) { XFeatureCall extensionProvider = getXbaseFactory().createXFeatureCall(); extensionProvider.setFeature(field); return extensionProvider; } else { XMemberFeatureCall extensionProvider = getXbaseFactory().createXMemberFeatureCall(); extensionProvider.setFeature(field); XFeatureCall thisAccess = getXbaseFactory().createXFeatureCall(); thisAccess.setFeature(thisFeature); extensionProvider.setMemberCallTarget(thisAccess); return extensionProvider; } }
superCall.setXExpression(call); superCall.setDocumentation(block.getAutoGeneratedActionString()); call.setFeature(superOperation); call.setMemberCallTarget(superCall.createReferenceToSuper()); final List<XExpression> arguments = call.getMemberCallArguments(); for (final IFormalParameterBuilder currentParam : sarlParams) { final XFeatureCall argumentSource = XbaseFactory.eINSTANCE.createXFeatureCall();
@Override protected void internalSetValue(InternalEObject featureCall, EReference structuralFeature, JvmIdentifiableElement newValue) { super.internalSetValue(featureCall, structuralFeature, newValue); if (featureCall instanceof XFeatureCall) { XFeatureCall casted = (XFeatureCall) featureCall; if (casted != getExpression()) { casted.setPackageFragment(true); } else { casted.setTypeLiteral(true); } } else if (featureCall instanceof XMemberFeatureCall) { XMemberFeatureCall casted = (XMemberFeatureCall) featureCall; if (casted != getExpression()) { casted.setPackageFragment(true); } else { casted.setTypeLiteral(true); } XExpression target = casted.getMemberCallTarget(); IFeatureLinkingCandidate candidate = getLinkingCandidate(target); if (candidate == null || !candidate.isTypeLiteral()) { resolveLinkingProxy((InternalEObject) target, newValue, structuralFeature, XbasePackage.XABSTRACT_FEATURE_CALL__FEATURE); } } }
private void checkForImpureJavaCallsInternal(XExpression xExpression) { Iterator<EObject> eAllContents = Iterators.concat(Iterators.singletonIterator(xExpression), xExpression.eAllContents()); while (eAllContents.hasNext()) { EObject nextEObject = eAllContents.next(); if (nextEObject instanceof XMemberFeatureCall) { XMemberFeatureCall xFeatureCall = (XMemberFeatureCall) nextEObject; JvmIdentifiableElement jvmIdentifiableElement = xFeatureCall.getFeature(); if (jvmIdentifiableElement instanceof JvmOperation) { JvmOperation jvmOperation = (JvmOperation) jvmIdentifiableElement; if (!jvmOperation.eIsProxy() && !isPure(jvmOperation)) { warning("Impure method call " + jvmOperation.getQualifiedName(), xFeatureCall, XbasePackage.Literals.XABSTRACT_FEATURE_CALL__FEATURE, IssueCodes.CHECK_WITH_IMPURE_JAVA_CALLS); } } } } }
protected IScope doGetTypeScope(XMemberFeatureCall call, JvmType type) { if (call.isPackageFragment()) { if (type instanceof JvmDeclaredType) { int segmentIndex = countSegments(call); String packageName = ((JvmDeclaredType) type).getPackageName(); List<String> splitted = Strings.split(packageName, '.'); String segment = splitted.get(segmentIndex); return new SingletonScope(EObjectDescription.create(segment, type), IScope.NULLSCOPE); } return IScope.NULLSCOPE; } else { if (type instanceof JvmDeclaredType && ((JvmDeclaredType) type).getDeclaringType() == null) { return new SingletonScope(EObjectDescription.create(type.getSimpleName(), type), IScope.NULLSCOPE); } else { XAbstractFeatureCall target = (XAbstractFeatureCall) call.getMemberCallTarget(); if (target.isPackageFragment()) { String qualifiedName = type.getQualifiedName(); int dot = qualifiedName.lastIndexOf('.'); String simpleName = qualifiedName.substring(dot + 1); return new SingletonScope(EObjectDescription.create(simpleName, type), IScope.NULLSCOPE); } else { return new SingletonScope(EObjectDescription.create(type.getSimpleName(), type), IScope.NULLSCOPE); } } } }