@Override public LightweightTypeReference getActualExpressionType() { return resolution.getActualType(expression); }
protected LightweightTypeReference getActualType(/* @Nullable */ XExpression expression) { if (expression == null) return null; return state.getResolvedTypes().getActualType(expression); }
protected JvmTypeReference doGetTypeReferenceWithCurrentTypeResolver() { LightweightTypeReference actualType = returnType ? resolvedTypes.getReturnType(expression) : resolvedTypes.getActualType(expression); if (actualType == null) { computeTypes(resolvedTypesByContext, resolvedTypes, session, member); actualType = returnType ? resolvedTypes.getExpectedReturnType(expression) : resolvedTypes.getExpectedType(expression); if (actualType == null) actualType = returnType ? resolvedTypes.getReturnType(expression) : resolvedTypes.getActualType(expression); } if (actualType == null) return null; return toJavaCompliantTypeReference(convertLocalType(actualType), session); }
protected IFeatureScopeSession addExtensionsToMemberSession(ResolvedTypes resolvedTypes, IFeatureScopeSession featureScopeSession, JvmDeclaredType type) { IEObjectDescription thisDescription = featureScopeSession.getLocalElement(IFeatureNames.THIS); if (thisDescription == null) { throw new IllegalStateException("Cannot find feature 'THIS'"); } JvmIdentifiableElement thisFeature = (JvmIdentifiableElement) thisDescription.getEObjectOrProxy(); IFeatureScopeSession childSession = addExtensionFieldsToMemberSession( resolvedTypes, featureScopeSession, type, thisFeature, Sets.<String>newHashSetWithExpectedSize(8), Sets.<JvmType>newHashSetWithExpectedSize(4)); XFeatureCall thisAccess = getXbaseFactory().createXFeatureCall(); thisAccess.setFeature(thisFeature); LightweightTypeReference thisType = resolvedTypes.getActualType(thisFeature); childSession = childSession.addToExtensionScope(Collections.<XExpression, LightweightTypeReference>singletonMap(thisAccess, thisType)); return childSession; }
protected LightweightTypeReference getDeclaredType(JvmIdentifiableElement feature) { LightweightTypeReference result = state.getResolvedTypes().getActualType(feature); if (result == null) { return getState().getReferenceOwner().newAnyTypeReference(); } return result; }
@Override /* @Nullable */ protected LightweightTypeReference getExpectedType() { JvmOperation operation = annotationValue.getOperation(); LightweightTypeReference result = getResolvedTypes().getActualType(operation); if (result != null && result.isArray()) { return result.getComponentType(); } return result; }
List<LightweightTypeReference> types = Lists.newArrayListWithCapacity(cases.size()); for (JvmOperation operation : cases) { LightweightTypeReference caseType = resolvedTypes.getActualType(operation); types.add(caseType);
@Override public void addExtensionsToCurrentScope(List<? extends JvmIdentifiableElement> extensionProviders) { if (extensionProviders.isEmpty()) return; if (extensionProviders.size() == 1) { addExtensionToCurrentScope(extensionProviders.get(0)); return; } Map<XExpression, LightweightTypeReference> prototypeToType = Maps2.newLinkedHashMapWithExpectedSize(extensionProviders.size()); for(JvmIdentifiableElement extensionProvider: extensionProviders) { LightweightTypeReference knownType = getResolvedTypes().getActualType(extensionProvider); if (knownType != null && !knownType.isAny() && !knownType.isUnknown()) { XFeatureCall prototype = getResolver().getXbaseFactory().createXFeatureCall(); prototype.setFeature(extensionProvider); prototypeToType.put(prototype, knownType); } } if (!prototypeToType.isEmpty()) featureScopeSession = featureScopeSession.addToExtensionScope(prototypeToType); }
/** * Returns <code>null</code> if the given operation declares it's own return type or if it does not override * another operation. */ /* @Nullable */ @SuppressWarnings("unused") protected LightweightTypeReference getReturnTypeOfOverriddenOperation(JvmOperation operation, ResolvedTypes resolvedTypes, IFeatureScopeSession session) { if (operation.getVisibility() == JvmVisibility.PRIVATE) return null; if (InferredTypeIndicator.isInferred(operation.getReturnType())) { LightweightTypeReference declaringType = resolvedTypes.getActualType(operation.getDeclaringType()); if (declaringType == null) { throw new IllegalStateException("Cannot determine declaring type of operation: " + operation); } LightweightTypeReference result = overrideHelper.getReturnTypeOfOverriddenOperation(operation, declaringType); return result; } return null; }
@Override public void addExtensionToCurrentScope(JvmIdentifiableElement extensionProvider) { LightweightTypeReference knownType = getResolvedTypes().getActualType(extensionProvider); if (knownType != null && !knownType.isAny() && !knownType.isUnknown()) { XFeatureCall prototype = getResolver().getXbaseFactory().createXFeatureCall(); prototype.setFeature(extensionProvider); featureScopeSession = featureScopeSession.addToExtensionScope(Collections.<XExpression, LightweightTypeReference>singletonMap(prototype, knownType)); } }
public void reassignType(JvmIdentifiableElement identifiable, /* @Nullable */ LightweightTypeReference reference) { if (reference != null) { LightweightTypeReference actualType = getActualType(identifiable); if (actualType != null) { if (actualType.getKind() == LightweightTypeReference.KIND_UNBOUND_TYPE_REFERENCE && !((UnboundTypeReference) actualType).internalIsResolved()) {
@Override public void applyToComputationState() { ResolvedTypes resolvedTypes = getState().getResolvedTypes(); TypeExpectation expectation = new TypeExpectation(null, getState(), false); LightweightTypeReference actualType = resolvedTypes.getActualType(getFeature()); if (actualType == null) throw new IllegalStateException("Cannot determine actual type of already resolved implicit first argument"); resolvedTypes.acceptType(getFeatureCall(), expectation, actualType.copyInto(resolvedTypes.getReferenceOwner()), false, ConformanceFlags.UNCHECKED); super.applyToComputationState(); }
@Override public void applyToComputationState() { super.applyToComputationState(); XAbstractFeatureCall featureCall = getFeatureCall(); if (featureCall instanceof XMemberFeatureCall) { XExpression target = ((XMemberFeatureCall) featureCall).getMemberCallTarget(); if (target == null || !(target instanceof XAbstractFeatureCall)) throw new IllegalStateException(); XAbstractFeatureCall targetFeatureCall = (XAbstractFeatureCall) target; ResolvedTypes resolvedTypes = getState().getResolvedTypes(); LightweightTypeReference targetType = resolvedTypes.getActualType(targetFeatureCall.getFeature()); if (targetType == null) { throw new IllegalStateException(); } TypeExpectation expectation = new TypeExpectation(null, getState(), false); resolvedTypes.acceptType(targetFeatureCall, expectation, targetType.copyInto(resolvedTypes.getReferenceOwner()), false, ConformanceFlags.UNCHECKED); } }
LightweightTypeReference fieldType = resolvedTypes.getActualType(field); extensionProviders.put(extensionProvider, fieldType);
if (inheritedDispatcher != null) { JvmFormalParameter inheritedParameter = inheritedDispatcher.getParameters().get(idx); inheritedParameterType = resolvedTypes.getActualType(inheritedParameter); break; LightweightTypeReference parameterType = resolvedTypes.getActualType(parameter); if (parameterType != null && !parameterType.isType(Void.class)) { if (inheritedParameterType != null) {
throw new IllegalStateException("No resolved type found. Type was: " + dispatchCase.getIdentifier()); dispatchCaseResults.add(dispatchCaseResolvedTypes.getActualType(dispatchCase)); if (InferredTypeIndicator.isInferred(dispatchCase.getReturnType())) { if (declaredDispatcherType == null) { dispatchCaseResults.add(childResolvedTypes.getActualType(dispatchCase)); dispatchCaseResults.add(childResolvedTypes.getActualType(dispatchCase)); LightweightTypeReference explicitType = dispatchCaseResolvedTypes.getActualType(dispatchCase); dispatchCaseResults.add(explicitType);
return null; if (InferredTypeIndicator.isInferred(operation.getReturnType())) { LightweightTypeReference declaringType = resolvedTypes.getActualType(operation.getDeclaringType()); if (declaringType == null) { throw new IllegalStateException("Cannot determine declaring type of operation: " + operation);
if (extensionProvider == null) { extensionProvider = createExtensionProvider(thisFeature, field); fieldType = resolvedTypes.getActualType(field); } else { fieldType = getSarlCapacityFieldType(resolvedTypes, field);
@Override /* @Nullable */ protected LightweightTypeReference getExpectedType() { LightweightTypeReference expectedType = super.getExpectedType(); if (expectedType != null) { return expectedType; } if (dispatcher != null) { JvmOperation operation = (JvmOperation) getMember(); if (!InferredTypeIndicator.isInferred(dispatcher.getReturnType())) { LightweightTypeReference result = getResolvedTypes().getActualType(dispatcher); if (result != null) InferredTypeIndicator.resolveTo(operation.getReturnType(), result.toJavaCompliantTypeReference()); return result; } } return inheritedExpectedType; }
@Override public void applyToComputationState() { ResolvedTypes resolvedTypes = getState().getResolvedTypes(); LightweightTypeReference actualType = resolvedTypes.getActualType(getFeature()); if (actualType == null) throw new IllegalStateException("Cannot determine actual type of already resolved implicit receiver"); LightweightTypeReference expectedReceiverType = new FeatureLinkHelper().getExpectedReceiverType(getOwner().getFeature(), actualType); if (expectedReceiverType != null) expectedReceiverType = expectedReceiverType.copyInto(resolvedTypes.getReferenceOwner()); TypeExpectation expectation = new TypeExpectation(expectedReceiverType, getState(), false); resolvedTypes.acceptType(getFeatureCall(), expectation, actualType.copyInto(resolvedTypes.getReferenceOwner()), false, ConformanceFlags.UNCHECKED); super.applyToComputationState(); }