@Override public Boolean apply(final JvmOperation it) { boolean _isStatic = it.isStatic(); return Boolean.valueOf((!_isStatic)); } };
@Override public boolean isStatic() { return this.getDelegate().isStatic(); }
@Override protected boolean isRawTypeInheritance() { if (getDeclaration().isStatic()) { return false; } return super.isRawTypeInheritance(); }
/** Replies if the given type is a functional interface. * * <p>This function does not test if the {@code @FunctionalInterface} is attached to the type. * The function counts the number of operations. * * @param type the type to test. * @param sarlSignatureProvider the provider of SARL operation signatures. * @return <code>true</code> if the given type is final. */ public static boolean isFunctionalInterface(JvmGenericType type, IActionPrototypeProvider sarlSignatureProvider) { if (type != null && type.isInterface()) { final Map<ActionPrototype, JvmOperation> operations = new HashMap<>(); populateInterfaceElements(type, operations, null, sarlSignatureProvider); if (operations.size() == 1) { final JvmOperation op = operations.values().iterator().next(); return !op.isStatic() && !op.isDefault(); } } return false; }
private Iterable<JvmOperation> getFixtureMethods(final JvmDeclaredType type) { final Function1<JvmOperation, Boolean> _function = (JvmOperation it) -> { return Boolean.valueOf(((Objects.equal(it.getVisibility(), JvmVisibility.PUBLIC) && (!it.isStatic())) && this.hasFixtureMethodAnnotation(it))); }; return IterableExtensions.<JvmOperation>filter(Iterables.<JvmOperation>filter(type.getAllFeatures(), JvmOperation.class), _function); }
protected int getFlags(JvmOperation operation) { int flags = 0; if (dispatchHelper.isDispatcherFunction(operation)) flags = descriptionFlags.setDispatcherOperation(flags); if (operation.isStatic()) flags = descriptionFlags.setStatic(flags); return flags; }
if (next instanceof JvmOperation) { JvmOperation operation = (JvmOperation) next; if (!operation.isStatic()) {
if (next instanceof JvmOperation) { JvmOperation operation = (JvmOperation) next; if (!operation.isStatic()) {
protected void createMethods(Class<?> clazz, JvmDeclaredType result) { try { Method[] declaredMethods = clazz.getDeclaredMethods(); if (declaredMethods.length != 0) { boolean intf = clazz.isInterface() && !clazz.isAnnotation(); InternalEList<JvmMember> members = (InternalEList<JvmMember>)result.getMembers(); for (Method method : declaredMethods) { if (!method.isSynthetic()) { JvmOperation operation = createOperation(method); if (clazz.isAnnotation()) { setDefaultValue(operation, method); } else if (intf && !operation.isAbstract() && !operation.isStatic()) { operation.setDefault(true); } members.addUnique(operation); } } } } catch (NoClassDefFoundError e) { logNoClassDefFoundError(e, clazz, "methods"); } }
protected OverrideCheckDetails getPrimaryValidDetail(IResolvedOperation overriding, JvmOperation overridden) { OverrideCheckDetails result = OverrideCheckDetails.IMPLEMENTATION; JvmOperation declaration = overriding.getDeclaration(); if (declaration.isStatic()) { result = OverrideCheckDetails.SHADOWED; } else if (declaration.isAbstract()) { if (overridden.isAbstract()) { result = OverrideCheckDetails.REPEATED; } else { result = OverrideCheckDetails.REDECLARATION; } } else if (!overridden.isAbstract()) { result = OverrideCheckDetails.OVERRIDE; } return result; }
@SuppressWarnings("unused") protected void _computeTypes(Map<JvmIdentifiableElement, ResolvedTypes> preparedResolvedTypes, ResolvedTypes resolvedTypes, IFeatureScopeSession featureScopeSession, JvmOperation operation) { ResolvedTypes childResolvedTypes = preparedResolvedTypes.get(operation); if (childResolvedTypes == null) { if (preparedResolvedTypes.containsKey(operation)) return; throw new IllegalStateException("No resolved type found. Operation was: " + operation.getIdentifier()); } else { preparedResolvedTypes.put(operation, null); } OperationBodyComputationState state = new OperationBodyComputationState(childResolvedTypes, operation.isStatic() ? featureScopeSession : featureScopeSession.toInstanceContext(), operation); addExtensionProviders(state, operation.getParameters()); markComputing(operation.getReturnType()); try { state.computeTypes(); } finally { unmarkComputing(operation.getReturnType()); } computeAnnotationTypes(childResolvedTypes, featureScopeSession, operation); computeLocalTypes(preparedResolvedTypes, childResolvedTypes, featureScopeSession, operation); mergeChildTypes(childResolvedTypes); }
public boolean isLocalTypeParameter(EObject context, JvmTypeParameter parameter) { if (context == parameter.getDeclarator()) return true; if (context instanceof JvmOperation && ((JvmOperation) context).isStatic()) return false; if (context instanceof JvmDeclaredType && ((JvmDeclaredType) context).isStatic()) return false; JvmIdentifiableElement jvmElement = contextProvider.getNearestLogicalContainer(context); if (jvmElement != null) { return isLocalTypeParameter(jvmElement, parameter); } EObject container = context.eContainer(); if (container == null) { return false; } return isLocalTypeParameter(container, parameter); }
@Override protected void checkAssignment(XExpression expression, EStructuralFeature feature, boolean simpleAssignment) { if (simpleAssignment && expression instanceof XAbstractFeatureCall) { final JvmIdentifiableElement assignmentFeature = ((XAbstractFeatureCall) expression).getFeature(); if (assignmentFeature instanceof JvmField) { final JvmField field = (JvmField) assignmentFeature; if (!field.isFinal()) { return; } final JvmIdentifiableElement container = getLogicalContainerProvider().getNearestLogicalContainer(expression); if (container != null && container instanceof JvmOperation) { final JvmOperation operation = (JvmOperation) container; if (operation.isStatic() && field.getDeclaringType() == operation.getDeclaringType() && Utils.STATIC_CONSTRUCTOR_NAME.equals(operation.getSimpleName())) { return; } } } } super.checkAssignment(expression, feature, simpleAssignment); }
protected boolean isCandidate(final LightweightTypeReference type, final IResolvedExecutable executable, final IVisibilityHelper visibilityHelper) { JvmDeclaredType declaringType = executable.getDeclaration().getDeclaringType(); if (((type.getType() != declaringType) && this.isVisible(executable, visibilityHelper))) { JvmExecutable rawExecutable = executable.getDeclaration(); if ((rawExecutable instanceof JvmOperation)) { JvmOperation operation = ((JvmOperation)rawExecutable); if ((operation.isFinal() || operation.isStatic())) { return false; } else { if (((type.getType() instanceof JvmGenericType) && ((JvmGenericType) type.getType()).isInterface())) { return (((declaringType instanceof JvmGenericType) && ((JvmGenericType) declaringType).isInterface()) && (!operation.isAbstract())); } else { return true; } } } else { return true; } } return false; }
appendable.append("abstract "); boolean _isStatic = it.isStatic(); if (_isStatic) { appendable.append("static "); if ((((((!it.isAbstract()) && (!it.isStatic())) && config.getJavaSourceVersion().isAtLeast(JavaVersion.JAVA8)) && (it.eContainer() instanceof JvmGenericType)) && ((JvmGenericType) it.eContainer()).isInterface())) { appendable.append("default ");
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(); } } }
@Override /* @Nullable */ protected JvmTypeReference doGetTypeReference(XComputedTypeReferenceImplCustom context) { try { CreateExtensionInfo createExtensionInfo = createFunction.getCreateExtensionInfo(); XExpression expression = createExtensionInfo.getCreateExpression(); LightweightTypeReference actualType = resolvedTypes.getReturnType(expression); if (actualType == null) { JvmOperation operation = typeResolver.associations.getDirectlyInferredOperation(createFunction); if (operation != null) { IFeatureScopeSession session = operation.isStatic() ? featureScopeSession : featureScopeSession.toInstanceContext(); typeResolver.computeTypes(resolvedTypesByContext, resolvedTypes, session, operation); actualType = resolvedTypes.getReturnType(expression); } } if (actualType == null) return null; // actualType may not be java compliant but still carry more information than the // java compliant reference JvmTypeReference result = typeResolver.toJavaCompliantTypeReference(actualType, featureScopeSession); if (actualType.isMultiType() || result.getType() != actualType.getType()) { resolvedTypes.setType(param, resolvedTypes.getReferenceOwner().toLightweightTypeReference(result)); resolvedTypes.reassignType(param, actualType); } return result; } finally { context.unsetTypeProviderWithoutNotification(); } } }
protected SignatureHashBuilder appendSignature(JvmOperation operation) { appendVisibility(operation.getVisibility()).append(" "); if (operation.isAbstract()) append("abstract "); if (operation.isStatic()) append("static "); if (operation.isFinal()) append("final "); appendType(operation.getReturnType()).appendTypeParameters(operation).append(" ") .append(operation.getSimpleName()).append("("); for (JvmFormalParameter p : operation.getParameters()) { appendType(p.getParameterType()); append(" "); } append(") "); for (JvmTypeReference ex : operation.getExceptions()) { appendType(ex).append(" "); } return this; }
operation.setVisibility(visibility); operation.setStatic(source.isStatic()); if (!operation.isAbstract() && !operation.isStatic() && container.isInterface()) operation.setDefault(true); for (XtendParameter parameter : source.getParameters()) {