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 setFeature(JvmIdentifiableElement newFeature) { isLinked = newFeature != null && !newFeature.eIsProxy(); super.setFeature(newFeature); }
protected JvmIdentifiableElement getReferencedElement(EObject owner, EReference reference) { JvmIdentifiableElement referencedThing = (JvmIdentifiableElement) owner.eGet(reference); if (referencedThing != null && owner instanceof XConstructorCall && referencedThing.eIsProxy()) { JvmIdentifiableElement potentiallyLinkedType = batchTypeResolver.resolveTypes(owner).getLinkedFeature((XConstructorCall)owner); if (potentiallyLinkedType != null && !potentiallyLinkedType.eIsProxy()) { referencedThing = potentiallyLinkedType; } } return referencedThing; }
/** * Returns <code>true</code> if the linked receiver may be passed as an argument. Basically everything could * be passed as an argument except the linked receiver is null, a proxy or a reference to <code>super</code>. */ protected boolean isValidFeatureCallArgument(XExpression expression, JvmIdentifiableElement linkedReceiver, IFeatureScopeSession session) { if (linkedReceiver instanceof JvmType) { IEObjectDescription knownSuperType = session.getLocalElement(SUPER); if (knownSuperType != null && linkedReceiver == knownSuperType.getEObjectOrProxy()) { return false; } } return !(expression instanceof XAbstractFeatureCall) || linkedReceiver != null && !linkedReceiver.eIsProxy(); }
@Override public boolean isStatic() { JvmIdentifiableElement element = getFeature(); if (element != null && !element.eIsProxy()) { if (element instanceof JvmFeature && !(element instanceof JvmConstructor)) return ((JvmFeature) element).isStatic(); } return false; }
public boolean isMandatory(JvmIdentifiableElement feature) { if (feature.eIsProxy()) return false; if (feature instanceof DeclaredProperty) { return ((DeclaredProperty) feature).getDefault() == null; } JvmOperation operation = (JvmOperation) feature; for(JvmAnnotationReference annotation: operation.getAnnotations()) { if (Mandatory.class.getName().equals(annotation.getAnnotation().getIdentifier())) return true; } return false; }
/** * <!-- begin-user-doc --> * <!-- end-user-doc --> * @generated */ public JvmIdentifiableElement getFeature() { if (feature != null && feature.eIsProxy()) { InternalEObject oldFeature = (InternalEObject)feature; feature = (JvmIdentifiableElement)eResolveProxy(oldFeature); if (feature != oldFeature) { if (eNotificationRequired()) eNotify(new ENotificationImpl(this, Notification.RESOLVE, XbasePackage.XABSTRACT_FEATURE_CALL__FEATURE, oldFeature, feature)); } } return feature; }
@Override public JvmIdentifiableElement getFeature() { if (feature != null && feature.eIsProxy()) { // body copied from super impl InternalEObject oldFeature = (InternalEObject) feature; feature = (JvmIdentifiableElement) eResolveProxy(oldFeature); if (feature != oldFeature) { if (eNotificationRequired()) eNotify(new ENotificationImpl(this, Notification.RESOLVE, XbasePackage.XABSTRACT_FEATURE_CALL__FEATURE, oldFeature, feature)); } // and additionally maintain #isLinked flag isLinked = true; } return feature; }
public JvmIdentifiableElement getFeature(final XAbstractFeatureCall call, final EvaluationContext context) { Object _eGet = call.eGet(XbasePackage.Literals.XABSTRACT_FEATURE_CALL__FEATURE, false); JvmIdentifiableElement feature = ((JvmIdentifiableElement) _eGet); if (((feature == null) || feature.eIsProxy())) { feature = context.getResolvedTypes().getLinkedFeature(call); } return feature; }
@Override public String getConcreteSyntaxFeatureName() { List<INode> list = NodeModelUtils.findNodesForFeature(this, XbasePackage.Literals.XABSTRACT_FEATURE_CALL__FEATURE); if (list.size()!=1) { if (feature == null || feature.eIsProxy()) return "<unkown>"; return String.format("<implicit: %s>", feature.getIdentifier()); } INode node = list.get(0); if (node instanceof ILeafNode) { return node.getText(); } StringBuilder result = new StringBuilder(); for(ILeafNode leafNode: node.getLeafNodes()) { if (!leafNode.isHidden()) result.append(leafNode.getText()); } return result.toString(); }
/** * <!-- begin-user-doc --> * <!-- end-user-doc --> * @generated */ public JvmIdentifiableElement getFeature() { if (feature != null && feature.eIsProxy()) { InternalEObject oldFeature = (InternalEObject)feature; feature = (JvmIdentifiableElement)eResolveProxy(oldFeature); if (feature != oldFeature) { if (eNotificationRequired()) eNotify(new ENotificationImpl(this, Notification.RESOLVE, Mwe2Package.ASSIGNMENT__FEATURE, oldFeature, feature)); } } return feature; }
private Set<String> getAssignedFeatures( Map<String, Referrable> availableProperties, Component component) { Set<String> result = Sets.newHashSet(); if (component.isAutoInject()) { result.addAll(availableProperties.keySet()); } for(Assignment assignment: component.getAssignment()) { if (assignment.getFeature() != null && !assignment.getFeature().eIsProxy()) { JvmIdentifiableElement feature = assignment.getFeature(); if (feature instanceof JvmOperation) { result.add(Strings.toFirstLower((((JvmOperation)feature).getSimpleName().substring(3)))); } else if (feature instanceof JvmFeature) { result.add(((JvmFeature) feature).getSimpleName()); } else { result.add(((DeclaredProperty)feature).getName()); } } } return result; }
protected void resolveLinkingProxy(EReference structuralFeature, int featureId) { InternalEObject internalView = (InternalEObject) getExpression(); JvmIdentifiableElement newFeature = getFeature(); if (newFeature.eIsProxy()) { newFeature = (JvmIdentifiableElement) internalView.eResolveProxy((InternalEObject) newFeature); } pendingLinkingCandidateResolver.resolveLinkingProxy(internalView, newFeature, structuralFeature, featureId); }
public /* @Nullable */ String getSimpleName(JvmIdentifiableElement element) { if (element == null || element.eIsProxy()) { return null; } if (element instanceof JvmFeature) { return ((JvmFeature) element).getSimpleName(); } if (element instanceof JvmFormalParameter) { return ((JvmFormalParameter) element).getName(); } if (element instanceof XVariableDeclaration) { return ((XVariableDeclaration) element).getName(); } return element.getSimpleName(); } }
@Override public boolean hasSideEffects(XAbstractFeatureCall featureCall, boolean inspectContents) { if (super.hasSideEffects(featureCall, inspectContents)) { final JvmIdentifiableElement feature = featureCall.getFeature(); // Several operations are not marked with @Pure but they have a clear semantic without border effects, // e.g. the "is", "get" functions. if (feature != null && !feature.eIsProxy() && feature instanceof JvmOperation) { final JvmOperation operation = (JvmOperation) feature; return this.nameValidator.isNamePatternForNotPureOperation(operation) || !this.nameValidator.isNamePatternForPureOperation(operation) || !hasPrimitiveParameters(operation); } return true; } return false; }
@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); } } }
private static boolean isLocalExpression(XAbstractFeatureCall expression, ISideEffectContext context, boolean dereference) { if (expression.isTypeLiteral() || expression.isPackageFragment()) { return false; } final JvmIdentifiableElement feature = expression.getFeature(); if (feature != null && (feature.eIsProxy() || isExternalFeature(feature))) { return false; } if (feature instanceof XVariableDeclaration) { if (dereference) { final XVariableDeclaration variable = (XVariableDeclaration) feature; for (final XExpression value : context.getVariableValues(variable.getIdentifier())) { if (!isLocalExpression(value, context, dereference)) { return false; } } } } return true; }
@Override public boolean validate(IAcceptor<? super AbstractDiagnostic> result) { if (!getState().isInstanceContext()) { JvmIdentifiableElement implicitFeature = getFeature(); if (implicitFeature instanceof JvmType) { JvmIdentifiableElement feature = getState().getResolvedTypes().getLinkedFeature(getOwner()); if (feature == null || feature.eIsProxy() || !(feature instanceof JvmFeature)) return true; String message = "Cannot make an implicit reference to this from a static context"; AbstractDiagnostic diagnostic = new EObjectDiagnosticImpl(Severity.ERROR, IssueCodes.STATIC_ACCESS_TO_INSTANCE_MEMBER, message, getOwner(), XbasePackage.Literals.XABSTRACT_FEATURE_CALL__FEATURE, -1, null); result.accept(diagnostic); return false; } } return super.validate(result); }
protected IFeatureLinkingCandidate getKnownFeature(XAbstractFeatureCall featureCall, AbstractTypeComputationState state, ResolvedTypes resolvedTypes) { IFeatureLinkingCandidate result = resolvedTypes.getFeature(featureCall); if (result != null) { return new AppliedFeatureLinkingCandidate(result); } EObject proxyOrResolved = (EObject) featureCall.eGet(XbasePackage.Literals.XABSTRACT_FEATURE_CALL__FEATURE, false); if (proxyOrResolved == null) { return new NullFeatureLinkingCandidate(featureCall, state); } if (!proxyOrResolved.eIsProxy()) { return state.createResolvedLink(featureCall, (JvmIdentifiableElement) proxyOrResolved); } if (!encoder.isCrossLinkFragment(featureCall.eResource(), EcoreUtil.getURI(proxyOrResolved).fragment())) { JvmIdentifiableElement feature = featureCall.getFeature(); if (!feature.eIsProxy()) { return state.createResolvedLink(featureCall, feature); } } return null; }
protected void checkIsValidConstructorArgument(XExpression argument, JvmType containerType) { TreeIterator<EObject> iterator = EcoreUtil2.eAll(argument); while(iterator.hasNext()) { EObject partOfArgumentExpression = iterator.next(); if (partOfArgumentExpression instanceof XFeatureCall || partOfArgumentExpression instanceof XMemberFeatureCall) { XAbstractFeatureCall featureCall = (XAbstractFeatureCall) partOfArgumentExpression; XExpression actualReceiver = featureCall.getActualReceiver(); if(actualReceiver instanceof XFeatureCall && ((XFeatureCall)actualReceiver).getFeature() == containerType) { JvmIdentifiableElement feature = featureCall.getFeature(); if (feature != null && !feature.eIsProxy()) { if (feature instanceof JvmField) { if (!((JvmField) feature).isStatic()) error("Cannot refer to an instance field " + feature.getSimpleName() + " while explicitly invoking a constructor", partOfArgumentExpression, null, INVALID_CONSTRUCTOR_ARGUMENT); } else if (feature instanceof JvmOperation) { if (!((JvmOperation) feature).isStatic()) error("Cannot refer to an instance method while explicitly invoking a constructor", partOfArgumentExpression, null, INVALID_CONSTRUCTOR_ARGUMENT); } } } } else if(isLocalClassSemantics(partOfArgumentExpression)) { iterator.prune(); } } }