@Override public ITypeReferenceOwner getReferenceOwner() { return state.getReferenceOwner(); }
@Override public ITypeReferenceOwner getReferenceOwner() { return state.getReferenceOwner(); }
@Override public void assignType(QualifiedName name, JvmType rawType, LightweightTypeReference actualType) { resolvedTypes.reassignTypeWithoutMerge(rawType, actualType); featureScopeSession = featureScopeSession.addLocalElement(name, rawType, getReferenceOwner()); }
protected AbstractTypeExpectation createTypeExpectation(/* @Nullable */ LightweightTypeReference expectedType, AbstractTypeComputationState actualState, boolean returnType) { AbstractTypeExpectation result = null; if (expectedType != null) { LightweightTypeReference copied = expectedType.copyInto(actualState.getReferenceOwner()); result = new TypeExpectation(copied, actualState, returnType); } else { result = new NoExpectation(actualState, returnType); } return result; }
protected void resolveAgainstActualType(LightweightTypeReference declaredType, LightweightTypeReference actualType, final AbstractTypeComputationState state) { if (!actualType.isAny()) { // TODO this(..) and super(..) for generic types List<JvmTypeParameter> typeParameters = getDeclaredTypeParameters(); if (!typeParameters.isEmpty()) { // TODO actualType -(hint for)-> declared type == inferred // declared type -(hint for)-> actual type == expected TypeArgumentFromComputedTypeCollector.resolveAgainstActualType( declaredType, actualType, typeParameters, getTypeParameterMapping(), BoundTypeArgumentSource.EXPECTATION, state.getReferenceOwner()); } } }
protected AbstractTypeExpectation createTypeExpectation(/* @Nullable */ LightweightTypeReference expectedType, AbstractTypeComputationState actualState, boolean voidAllowed, boolean returnType) { AbstractTypeExpectation result = null; if (expectedType != null) { LightweightTypeReference copied = expectedType.copyInto(actualState.getReferenceOwner()); result = new RootTypeExpectation(copied, actualState); } else if (returnType) { result = new PendingRootExpectation(actualState, this, voidAllowed); } else { result = new RootNoExpectation(actualState, voidAllowed); } return result; }
@Override protected AbstractTypeExpectation createTypeExpectation(/* @Nullable */ LightweightTypeReference expectedType, AbstractTypeComputationState actualState, boolean returnType) { LightweightTypeReference type = expectedType != null ? expectedType.copyInto(actualState.getReferenceOwner()) : null; AbstractTypeExpectation result; if (type != null) { result = returnType ? new TypeExpectation(type, actualState, returnType) : new RootTypeExpectation(type, actualState); } else { result = returnType ? new NoExpectation(actualState, returnType) : new RootNoExpectation(actualState, true); } return result; }
@Override protected void resolveAgainstActualType(LightweightTypeReference declaredType, LightweightTypeReference actualType, final AbstractTypeComputationState state) { super.resolveAgainstActualType(declaredType, actualType, state); if (!isStatic() && !isExtension()) { DeferredTypeParameterHintCollector collector = new DeferredTypeParameterHintCollector(state.getReferenceOwner()); collector.processPairedReferences(declaredType, actualType); } }
@Override protected void resolveAgainstActualType(LightweightTypeReference declaredType, LightweightTypeReference actualType, final AbstractTypeComputationState state) { super.resolveAgainstActualType(declaredType, actualType, state); if (!isStatic() || ((actualType.hasTypeArguments() || actualType.isArray()) && getDeclaredTypeParameters().isEmpty())) { DeferredTypeParameterHintCollector collector = new DeferredTypeParameterHintCollector(state.getReferenceOwner()); collector.processPairedReferences(declaredType, actualType); } }
protected void assignType(JvmIdentifiableElement element, /* @Nullable */ LightweightTypeReference actualType, boolean addToChildScope) { if (actualType != null) { state.getResolvedTypes().setType(element, actualType); } else { state.getResolvedTypes().setType(element, state.getReferenceOwner().newAnyTypeReference()); } if (addToChildScope) state.addLocalToCurrentScope(element); }
@Override public final ITypeComputationResult computeTypes(/* @Nullable */ XExpression expression) { resolvedTypes.checkCanceled(); if (expression != null) { if (expression.eContainer() == null && expression.eResource() == null) throw new IllegalStateException("Dangling expression: " + expression); assert getResolvedTypes().doGetTypeData(expression) == null : "Expression was already resolved: " + expression; ExpressionAwareStackedResolvedTypes stackedResolvedTypes = doComputeTypes(expression); stackedResolvedTypes.performMergeIntoParent(); return new ResolutionBasedComputationResult(expression, resolvedTypes); } else { return new NoTypeResult(null, getReferenceOwner()); } }
featureScopeSession = featureScopeSession.addLocalElement(elementName, element, getReferenceOwner());