Examples with JvmOperation org.eclipse.xtext.common.types.JvmOperation used on opensource projects

Example 96 with JvmOperation

use of org.eclipse.xtext.common.types.JvmOperation in project xtext-xtend by eclipse.

the class XtendReentrantTypeResolver method _computeTypes.

@Override
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. Type was: " + operation.getIdentifier());
    }
    if (dispatchHelper.isDispatcherFunction(operation)) {
        // no associated expression, we just resolve it to the common super type of all associated cases
        // see #createTypeProvider and #_doPrepare
        preparedResolvedTypes.put(operation, null);
        computeAnnotationTypes(childResolvedTypes, featureScopeSession, operation);
        mergeChildTypes(childResolvedTypes);
    } else if (dispatchHelper.isDispatchFunction(operation) && InferredTypeIndicator.isInferred(operation.getReturnType())) {
        JvmOperation dispatcher = dispatchHelper.getDispatcherOperation(operation);
        if (dispatcher == null) {
            super._computeTypes(preparedResolvedTypes, resolvedTypes, featureScopeSession, operation);
            return;
        }
        List<JvmOperation> dispatchCasesWithDeclaredReturnType = new ArrayList<JvmOperation>();
        List<JvmOperation> dispatchCasesWithInferredReturnType = new ArrayList<JvmOperation>();
        List<JvmOperation> dispatchCases = dispatchHelper.getLocalDispatchCases(dispatcher);
        for (JvmOperation dispatchCase : dispatchCases) {
            if (InferredTypeIndicator.isInferred(dispatchCase.getReturnType())) {
                dispatchCasesWithInferredReturnType.add(dispatchCase);
            } else {
                dispatchCasesWithDeclaredReturnType.add(dispatchCase);
            }
        }
        try {
            markComputing(dispatcher.getReturnType());
            LightweightTypeReference declaredDispatcherType = getReturnTypeOfOverriddenOperation(dispatcher, childResolvedTypes, featureScopeSession);
            List<LightweightTypeReference> dispatchCaseResults = Lists.newArrayListWithCapacity(dispatchCases.size());
            LightweightTypeReference implicitVoid = null;
            LightweightTypeReference thrownVoid = null;
            for (JvmOperation dispatchCase : dispatchCasesWithDeclaredReturnType) {
                ResolvedTypes dispatchCaseResolvedTypes = preparedResolvedTypes.get(dispatchCase);
                if (dispatchCaseResolvedTypes == null) {
                    if (preparedResolvedTypes.containsKey(dispatchCase)) {
                        dispatchCaseResolvedTypes = childResolvedTypes;
                    }
                }
                if (dispatchCaseResolvedTypes == null) {
                    throw new IllegalStateException("No resolved type found. Type was: " + dispatchCase.getIdentifier());
                }
                dispatchCaseResults.add(dispatchCaseResolvedTypes.getActualType(dispatchCase));
            }
            List<ResolvedTypes> mergeUs = Lists.newArrayList();
            for (JvmOperation dispatchCase : dispatchCasesWithInferredReturnType) {
                ResolvedTypes dispatchCaseResolvedTypes = dispatchCase == operation ? childResolvedTypes : preparedResolvedTypes.get(dispatchCase);
                if (dispatchCaseResolvedTypes == null) {
                    if (preparedResolvedTypes.containsKey(dispatchCase)) {
                        if (InferredTypeIndicator.isInferred(dispatchCase.getReturnType())) {
                            if (declaredDispatcherType == null) {
                                dispatchCaseResults.add(childResolvedTypes.getActualType(dispatchCase));
                            }
                        } else {
                            dispatchCaseResults.add(childResolvedTypes.getActualType(dispatchCase));
                        }
                    } else {
                        throw new IllegalStateException("No resolved type found. Type was: " + dispatchCase.getIdentifier());
                    }
                } else {
                    mergeUs.add(dispatchCaseResolvedTypes);
                    preparedResolvedTypes.put(dispatchCase, null);
                    OperationBodyComputationState state = new DispatchOperationBodyComputationState(dispatchCaseResolvedTypes, dispatchCase.isStatic() ? featureScopeSession : featureScopeSession.toInstanceContext(), dispatchCase, dispatcher, declaredDispatcherType);
                    addExtensionProviders(state, dispatchCase.getParameters());
                    ITypeComputationResult dispatchCaseResult = null;
                    try {
                        markComputing(dispatchCase.getReturnType());
                        dispatchCaseResult = state.computeTypes();
                    } finally {
                        unmarkComputing(dispatchCase.getReturnType());
                    }
                    if (InferredTypeIndicator.isInferred(dispatchCase.getReturnType())) {
                        if (declaredDispatcherType == null) {
                            LightweightTypeReference returnType = dispatchCaseResult.getReturnType();
                            if (returnType != null) {
                                if (returnType.isPrimitiveVoid()) {
                                    int conformanceFlags = dispatchCaseResult.getConformanceFlags();
                                    if ((conformanceFlags & ConformanceFlags.THROWN_EXCEPTION) == 0) {
                                        if ((conformanceFlags & ConformanceFlags.NO_IMPLICIT_RETURN) != 0) {
                                            dispatchCaseResults.add(returnType);
                                        } else {
                                            implicitVoid = returnType;
                                        }
                                    } else {
                                        thrownVoid = returnType;
                                    }
                                } else {
                                    dispatchCaseResults.add(returnType);
                                }
                            }
                        }
                    } else {
                        LightweightTypeReference explicitType = dispatchCaseResolvedTypes.getActualType(dispatchCase);
                        dispatchCaseResults.add(explicitType);
                    }
                    computeAnnotationTypes(dispatchCaseResolvedTypes, featureScopeSession, dispatchCase);
                    computeLocalTypes(preparedResolvedTypes, dispatchCaseResolvedTypes, featureScopeSession, dispatchCase);
                }
            }
            LightweightTypeReference commonDispatchType = normalizeDispatchReturnType(declaredDispatcherType, dispatchCaseResults, implicitVoid, thrownVoid, childResolvedTypes);
            if (commonDispatchType != null) {
                resolveDispatchCaseTypes(dispatcher, dispatchCasesWithInferredReturnType, commonDispatchType, featureScopeSession);
            }
            // deferred merge since #normalizeDispatchReturnType may add more hints to the different dispatch cases
            for (ResolvedTypes mergeMe : mergeUs) {
                mergeChildTypes(mergeMe);
            }
        } finally {
            unmarkComputing(dispatcher.getReturnType());
        }
    } else {
        super._computeTypes(preparedResolvedTypes, resolvedTypes, featureScopeSession, operation);
    }
}

Example 97 with JvmOperation

use of org.eclipse.xtext.common.types.JvmOperation in project xtext-xtend by eclipse.

the class XtendReentrantTypeResolver method _doPrepare.

/**
 * Initializes the type inference strategy for the cache field for create extensions.
 */
@Override
protected void _doPrepare(ResolvedTypes resolvedTypes, IFeatureScopeSession featureScopeSession, JvmField field, Map<JvmIdentifiableElement, ResolvedTypes> resolvedTypesByContext) {
    JvmTypeReference knownType = field.getType();
    if (InferredTypeIndicator.isInferred(knownType)) {
        XComputedTypeReference castedKnownType = (XComputedTypeReference) knownType;
        EObject sourceElement = associations.getPrimarySourceElement(field);
        if (sourceElement instanceof XtendFunction) {
            XtendFunction function = (XtendFunction) sourceElement;
            if (function.getCreateExtensionInfo() != null) {
                JvmOperation operation = associations.getDirectlyInferredOperation(function);
                if (operation != null) {
                    declareTypeParameters(resolvedTypes, field, resolvedTypesByContext);
                    XComputedTypeReference fieldType = getServices().getXtypeFactory().createXComputedTypeReference();
                    fieldType.setTypeProvider(new CreateCacheFieldTypeReferenceProvider(operation, resolvedTypes, featureScopeSession));
                    castedKnownType.setEquivalent(fieldType);
                    return;
                }
            }
        }
    }
    super._doPrepare(resolvedTypes, featureScopeSession, field, resolvedTypesByContext);
    doPrepareLocalTypes(resolvedTypesByContext.get(field), featureScopeSession, field, resolvedTypesByContext);
}

Example 98 with JvmOperation

use of org.eclipse.xtext.common.types.JvmOperation in project xtext-xtend by eclipse.

the class XtendValidator method checkLocalUsageOfDeclaredXtendFunction.

@Check
public void checkLocalUsageOfDeclaredXtendFunction(XtendFunction function) {
    if (doCheckValidMemberName(function) && !isIgnored(UNUSED_PRIVATE_MEMBER)) {
        JvmOperation jvmOperation = function.isDispatch() ? associations.getDispatchOperation(function) : associations.getDirectlyInferredOperation(function);
        if (jvmOperation != null && jvmOperation.getVisibility() == JvmVisibility.PRIVATE && !isLocallyUsed(jvmOperation, getOutermostType(function))) {
            String message = "The method " + jvmOperation.getSimpleName() + uiStrings.parameters(jvmOperation) + " from the type " + getDeclaratorName(jvmOperation) + " is never used locally.";
            addIssueToState(UNUSED_PRIVATE_MEMBER, message, XtendPackage.Literals.XTEND_FUNCTION__NAME);
        }
    }
}

Example 99 with JvmOperation

use of org.eclipse.xtext.common.types.JvmOperation in project xtext-xtend by eclipse.

the class XtendValidator method checkCreateFunctionIsNotTypeVoid.

@Check
public void checkCreateFunctionIsNotTypeVoid(XtendFunction func) {
    if (func.getCreateExtensionInfo() == null)
        return;
    if (func.getReturnType() == null) {
        JvmOperation operation = associations.getDirectlyInferredOperation(func);
        if (operation != null && isPrimitiveVoid(operation.getReturnType())) {
            error("void is an invalid type for the create method " + func.getName(), func, XtendPackage.Literals.XTEND_FUNCTION__NAME, INVALID_USE_OF_TYPE);
        }
    } else if (isPrimitiveVoid(func.getReturnType())) {
        if (func.getReturnType() != null)
            error("Create method " + func.getName() + " may not declare return type void.", func.getReturnType(), null, INVALID_USE_OF_TYPE);
        else
            error("The inherited return type void of " + func.getName() + " is invalid for create method.", func.getReturnType(), null, INVALID_USE_OF_TYPE);
    }
}

Example 100 with JvmOperation

use of org.eclipse.xtext.common.types.JvmOperation in project xtext-xtend by eclipse.

the class XtendGenerator method getAddedDeclarations.

protected ArrayList<JvmMember> getAddedDeclarations(final JvmGenericType it, final AnonymousClass anonymousClass) {
    final ArrayList<JvmMember> result = CollectionLiterals.<JvmMember>newArrayList();
    final JvmConstructor constructor = anonymousClass.getConstructorCall().getConstructor();
    int _size = constructor.getParameters().size();
    boolean _greaterEqualsThan = (_size >= 1);
    if (_greaterEqualsThan) {
        result.add(0, constructor);
    }
    Iterable<JvmField> _declaredFields = it.getDeclaredFields();
    Iterables.<JvmMember>addAll(result, _declaredFields);
    final Function1<JvmOperation, Boolean> _function = (JvmOperation it_1) -> {
        EObject _head = IterableExtensions.<EObject>head(this.getSourceElements(it_1));
        final XtendFunction function = ((XtendFunction) _head);
        boolean _isOverride = function.isOverride();
        return Boolean.valueOf((!_isOverride));
    };
    Iterable<JvmOperation> _filter = IterableExtensions.<JvmOperation>filter(it.getDeclaredOperations(), _function);
    Iterables.<JvmMember>addAll(result, _filter);
    Iterable<JvmDeclaredType> _filter_1 = Iterables.<JvmDeclaredType>filter(it.getMembers(), JvmDeclaredType.class);
    Iterables.<JvmMember>addAll(result, _filter_1);
    return result;
}