protected boolean isSimpleFeatureCall(XExpression switch1) { if (switch1 instanceof XFeatureCall) { XFeatureCall featureCall = (XFeatureCall) switch1; return !(featureCall.getFeature() instanceof JvmOperation); } 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); } } }
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 boolean hasJvmConstructorCall(XExpression obj) { if (!(obj instanceof XBlockExpression)) { return false; } XBlockExpression blockExpression = (XBlockExpression) obj; EList<XExpression> expressions = blockExpression.getExpressions(); if (expressions.isEmpty()) { return false; } XExpression expr = expressions.get(0); if (!(expr instanceof XFeatureCall)) { return false; } XFeatureCall featureCall = (XFeatureCall) expr; return featureCall.getFeature() instanceof JvmConstructor; }
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); } }
private String getReferenceName(XExpression expr) { if (this.codeReceiver.hasName(expr)) { return this.codeReceiver.getName(expr); } if (expr instanceof XFeatureCall) { final XFeatureCall featureCall = (XFeatureCall) expr; if (this.codeReceiver.hasName(featureCall.getFeature())) { return this.codeReceiver.getName(featureCall.getFeature()); } } return null; }
/** Replies all the variables that are referenced into the given expression. * * @param expression the expression. * @param onlyWritable if {@code true} only the writable variables are replied. Otherwise, all variables are replied. * @return the referenced variables. */ @SuppressWarnings("static-method") protected Map<XVariableDeclaration, XFeatureCall> getReferencedLocalVariable(XExpression expression, boolean onlyWritable) { final Map<XVariableDeclaration, XFeatureCall> localVariables = new TreeMap<>((k1, k2) -> { return k1.getIdentifier().compareTo(k2.getIdentifier()); }); for (final XFeatureCall featureCall : EcoreUtil2.getAllContentsOfType(expression, XFeatureCall.class)) { if (featureCall.getFeature() instanceof XVariableDeclaration) { final XVariableDeclaration localVariable = (XVariableDeclaration) featureCall.getFeature(); if ((!onlyWritable || localVariable.isWriteable()) && !localVariables.containsKey(localVariable)) { localVariables.put(localVariable, featureCall); } } } return localVariables; }
@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 isReferenceToSelf(XFeatureCall featureCall, JvmType type) { return !featureCall.isTypeLiteral() && !featureCall.isPackageFragment() && type.equals(featureCall.getFeature()) && IFeatureNames.SELF.getFirstSegment().equals(featureCall.getConcreteSyntaxFeatureName()); }
/** * @return the variable name under which the result of the expression is stored. Returns <code>null</code> if the * expression hasn't been assigned to a local variable before. */ /* @Nullable */ protected String getReferenceName(XExpression expr, ITreeAppendable b) { if (b.hasName(expr)) return b.getName(expr); if (expr instanceof XFeatureCall) { XFeatureCall featureCall = (XFeatureCall) expr; if (b.hasName(featureCall.getFeature())) return b.getName(featureCall.getFeature()); } return null; }
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 boolean isValidStaticState(XExpression receiver) { boolean validStaticState = true; if (receiver instanceof XMemberFeatureCall) { XExpression thisReference = ((XMemberFeatureCall) receiver).getMemberCallTarget(); if (thisReference instanceof XFeatureCall && ((XFeatureCall) thisReference).getFeature() instanceof JvmType) { validStaticState = getSession().isInstanceContext(); } } return validStaticState; }
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 void _toJavaStatement(final XFeatureCall expr, final ITreeAppendable b, boolean isReferenced) { // if it's a call to this() or super() make sure the arguments are forced to be compiled to expressions. if (expr.getFeature() instanceof JvmConstructor) { b.newLine(); featureCalltoJavaExpression(expr, b, false); b.append(";"); } else { _toJavaStatement((XAbstractFeatureCall) expr, b, isReferenced); } }
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 String getSwitchLocalVariableSimpleName(XSwitchExpression expr) { IdentifiableSimpleNameProvider nameProvider = getNameProvider(); String varName = nameProvider.getSimpleName(expr.getDeclaredParam()); if (varName != null) { return varName; } XExpression expression = expr.getSwitch(); if (!(expression instanceof XFeatureCall)) { return null; } XFeatureCall featureCall = (XFeatureCall) expression; JvmIdentifiableElement feature = featureCall.getFeature(); return nameProvider.getSimpleName(feature); }
@Override protected boolean validateArity(IAcceptor<? super AbstractDiagnostic> result) { if (getFeatureCall() instanceof XFeatureCall) { XExpression implicitReceiver = getImplicitReceiver(); if (implicitReceiver instanceof XFeatureCall) { JvmIdentifiableElement feature = ((XFeatureCall) implicitReceiver).getFeature(); if (feature instanceof JvmType && !getState().isInstanceContext()) { return false; } } } return super.validateArity(result); }
@Check public void checkDelegateConstructorIsFirst(XFeatureCall featureCall) { JvmIdentifiableElement feature = featureCall.getFeature(); if (feature != null && !feature.eIsProxy() && feature instanceof JvmConstructor) { JvmIdentifiableElement container = logicalContainerProvider.getNearestLogicalContainer(featureCall); if (container != null) { if (container instanceof JvmConstructor) { XExpression body = logicalContainerProvider.getAssociatedExpression(container); if (body == featureCall) return; if (body instanceof XBlockExpression) { List<XExpression> expressions = ((XBlockExpression) body).getExpressions(); if (expressions.isEmpty() || expressions.get(0) != featureCall) { error("Constructor call must be the first expression in a constructor", null, INVALID_CONSTRUCTOR_INVOCATION); } } } else { error("Constructor call must be the first expression in a constructor", null, INVALID_CONSTRUCTOR_INVOCATION); } } } }
/** Check for usage of the event functions in the behavior units. * * @param unit the unit to analyze. */ @Check(CheckType.EXPENSIVE) public void checkUnmodifiableEventAccess(SarlBehaviorUnit unit) { final boolean enable1 = !isIgnored(IssueCodes.DISCOURAGED_OCCURRENCE_READONLY_USE); final XExpression root = unit.getExpression(); final String occurrenceKw = this.grammarAccess.getOccurrenceKeyword(); for (final XFeatureCall child : EcoreUtil2.getAllContentsOfType(root, XFeatureCall.class)) { if (occurrenceKw.equals(child.getFeature().getIdentifier())) { checkUnmodifiableFeatureAccess(enable1, child, occurrenceKw); } } }
protected String getSwitchLocalVariableName(XSwitchExpression expr, ITreeAppendable b) { JvmFormalParameter declaredParam = expr.getDeclaredParam(); if (declaredParam != null) { if (b.hasName(declaredParam)) { return b.getName(declaredParam); } return null; } XExpression switchExpression = expr.getSwitch(); if (b.hasName(switchExpression)) { return b.getName(switchExpression); } if (switchExpression instanceof XFeatureCall) { XFeatureCall featureCall = (XFeatureCall) switchExpression; JvmIdentifiableElement feature = featureCall.getFeature(); if (b.hasName(feature)) { return b.getName(feature); } } return null; }