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);
}
}
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);
}
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);
}
}
}
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);
}
}
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;
}
Aggregations