protected boolean isDelegateConstructorCall(XExpression expression) { if(expression instanceof XFeatureCall) { JvmIdentifiableElement feature = ((XFeatureCall)expression).getFeature(); return (feature != null && !feature.eIsProxy() && feature instanceof JvmConstructor); } return false; }
protected String getIdentifier(JvmIdentifiableElement identifiable) { if (identifiable == null) return "/null/"; return identifiable.getIdentifier(); }
/** Replies the identifier that corresponds to the resource and the declaring type. * * @return the container identifier. */ public String getContainerID() { return this.resourceID + "/" + this.declaringType.getQualifiedName(); //$NON-NLS-1$ }
private String getQualifiedSimpleName(JvmIdentifiableElement element) { if (element.eContainer() instanceof JvmType) { return getQualifiedSimpleName((JvmIdentifiableElement) element.eContainer()) + "." + element.getSimpleName(); } return element.getSimpleName(); }
protected boolean isValidAssignmentName(IIdentifiableElementDescription description) { JvmIdentifiableElement candidate = description.getElementOrProxy(); if (candidate.eClass() == TypesPackage.Literals.JVM_OPERATION) { if (candidate.getSimpleName().equals(description.getName().getFirstSegment())) { return false; } else if (!candidate.getSimpleName().startsWith("set")) { return false; } } return true; }
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()); } }
@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(); }
protected String getVarName(JvmIdentifiableElement ex) { return ex.getSimpleName(); } }
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 isDisallowedCall(XAbstractFeatureCall call) { if (call != null && call.getFeature() != null) { final JvmIdentifiableElement feature = call.getFeature(); final String id = feature.getQualifiedName(); // Exit is forbidden on a agent-based system if ("java.lang.System.exit".equals(id)) { //$NON-NLS-1$ return !isInsideOOTypeDeclaration(call); } // Avoid any call to the hidden functions (function name contains "$" character). if (Utils.isHiddenMember(feature.getSimpleName()) && !Utils.isNameForHiddenCapacityImplementationCallingMethod(feature.getSimpleName())) { return true; } // Avoid any reference to private API. if (isPrivateAPI(feature) && !isPrivateAPI(call)) { return true; } } return false; }
EObject source, EStructuralFeature structuralFeature) { if (object instanceof JvmMember && object.eResource() != source.eResource()) { JvmMember member = (JvmMember) object; if (DeprecationUtil.isTransitivelyDeprecatedMember(member)) { object.getSimpleName(), uiStrings.parameters(member), FeatureKinds.getTypeName(container), FeatureKinds.getTypeName(member), getQualifiedSimpleName(container), object.getSimpleName()); } else if (member instanceof JvmConstructor) {
@Override public XExpression getAssociatedExpression(JvmIdentifiableElement element) { if (element == null) return null; Map<EObject, JvmIdentifiableElement> mapping = getLogicalContainerMapping(element.eResource()); for (Map.Entry<EObject, JvmIdentifiableElement> entry : mapping.entrySet()) { if (entry.getValue() == element && entry.getKey() instanceof XExpression) { return (XExpression) entry.getKey(); } } return null; }
@Override protected CandidateCompareResult getExpectedTypeCompareResultOther(AbstractPendingLinkingCandidate<?> right) { if (!(right instanceof FeatureLinkingCandidate) || getState().isIgnored(IssueCodes.SUSPICIOUSLY_OVERLOADED_FEATURE)) return CandidateCompareResult.OTHER; FeatureLinkingCandidate casted = (FeatureLinkingCandidate) right; XExpression otherImplicitReceiver = casted.getImplicitReceiver(); if (otherImplicitReceiver != null) { if (isStatic() == casted.isStatic()) { if (otherImplicitReceiver instanceof XAbstractFeatureCall && getImplicitReceiver() instanceof XAbstractFeatureCall) { JvmIdentifiableElement otherImplicitReceiverFeature = ((XAbstractFeatureCall) otherImplicitReceiver).getFeature(); if (otherImplicitReceiverFeature != ((XAbstractFeatureCall) getImplicitReceiver()).getFeature()) return CandidateCompareResult.SUSPICIOUS_OTHER; } } } else { if (isStatic() && casted.isStatic()) { JvmIdentifiableElement otherFeature = casted.getFeature(); if (getFeature().eContainer() != otherFeature.eContainer() && otherFeature.eResource() == getExpression().eResource()) { if (EcoreUtil.isAncestor(otherFeature.eContainer(), getFeature())) { return CandidateCompareResult.SUSPICIOUS_OTHER; } } } } return CandidateCompareResult.OTHER; }
public StringConcatenationClient getCompilationTemplate(final JvmIdentifiableElement it) { final CompilationTemplateAdapter adapter = IterableExtensions.<CompilationTemplateAdapter>head(Iterables.<CompilationTemplateAdapter>filter(it.eAdapters(), CompilationTemplateAdapter.class)); StringConcatenationClient _compilationTemplate = null; if (adapter!=null) { _compilationTemplate=adapter.getCompilationTemplate(); } return _compilationTemplate; }
@Check public void checkCompatibility(Assignment assignment) { JvmIdentifiableElement feature = assignment.getFeature(); if (feature.eIsProxy()) return; JvmTypeReference left = null; "A value of type '" + rightType.getQualifiedName('.') + "' can not be assigned to the feature " + feature.getIdentifier(), Mwe2Package.Literals.ASSIGNMENT__VALUE, ValidationMessageAcceptor.INSIGNIFICANT_INDEX,
public String getSimpleName() { return this.getDelegate().getSimpleName(); }
if (implicitFeature instanceof JvmType) { JvmIdentifiableElement feature = getState().getResolvedTypes().getLinkedFeature(getOwner()); if (feature == null || feature.eIsProxy() || !(feature instanceof JvmFeature)) return true; String message = String.format("Cannot make a static reference to the non-static %s %s from the type %s", typeName, feature.getSimpleName(), getFeature().getSimpleName()); AbstractDiagnostic diagnostic = new EObjectDiagnosticImpl(Severity.ERROR, IssueCodes.STATIC_ACCESS_TO_INSTANCE_MEMBER, message, getOwner(), } else if (implicitFeature instanceof JvmFeature && !((JvmFeature) implicitFeature).isStatic()) { JvmIdentifiableElement feature = getState().getResolvedTypes().getLinkedFeature(getOwner()); if (feature == null || feature.eIsProxy() || !(feature instanceof JvmFeature)) return true; String message = String.format("Cannot make an implicit static reference to the non-static extension %s", feature.getSimpleName()); AbstractDiagnostic diagnostic = new EObjectDiagnosticImpl(Severity.ERROR, IssueCodes.STATIC_ACCESS_TO_INSTANCE_MEMBER, message, getOwner(),
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; }
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; }