protected void computeArgumentTypes() { List<XExpression> arguments = getArguments(); for (XExpression argument : arguments) { if (getResolvedTypes().doGetTypeData(argument) == null) { AbstractTypeComputationState argumentState = state.withNonVoidExpectation(); argumentState.computeTypes(argument); } } }
protected void initializeArgumentTypeComputation() { if (arguments != null) return; getTypeParameterMapping(); // trigger lazy init arguments = state.getResolver().getExpressionArgumentFactory().createExpressionArguments(expression, this); }
@Override protected ExpressionTypeComputationState createExpressionComputationState(XExpression expression, StackedResolvedTypes typeResolution) { return new RootExpressionTypeComputationState(typeResolution, getFeatureScopeSession(), this, expression, getExpectedType()); } };
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); }
@Override protected List<AbstractTypeExpectation> getExpectations(AbstractTypeComputationState actualState, boolean returnType) { LightweightTypeReference type = getExpectedType(); 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 Collections.singletonList(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; }
protected IConstructorLinkingCandidate createResolvedLink(XConstructorCall constructorCall, JvmConstructor resolvedTo) { StackedResolvedTypes stackedResolvedTypes = resolvedTypes.pushTypes(constructorCall); ExpressionTypeComputationState state = createExpressionComputationState(constructorCall, stackedResolvedTypes); return new ResolvedConstructor(constructorCall, resolvedTo, getSingleExpectation(state), state); }
protected LightweightTypeReference getActualType(/* @Nullable */ XExpression expression) { if (expression == null) return null; return state.getResolvedTypes().getActualType(expression); }
@Override public TypeAssigner assignTypes() { TypeCheckpointComputationState state = new TypeCheckpointComputationState(getResolvedTypes(), getFeatureScopeSession(), this) { @Override protected ExpressionTypeComputationState createExpressionComputationState(XExpression expression, StackedResolvedTypes typeResolution) { return new RootExpressionTypeComputationState(typeResolution, getFeatureScopeSession(), this, expression, getExpectedType()); } }; return createTypeAssigner(state); }
@Override protected LightweightTypeReference acceptType(ResolvedTypes resolvedTypes, AbstractTypeExpectation expectation, LightweightTypeReference type, boolean returnType, int flags) { LightweightTypeReference result = resolvedTypes.acceptType(expression, expectation, type, returnType, flags); getParent().acceptType(expression, resolvedTypes, expectation, type, returnType, flags); return result; }
protected AbstractReentrantTypeReferenceProvider createTypeProvider( Map<JvmIdentifiableElement, ResolvedTypes> resolvedTypesByContext, ResolvedTypes resolvedTypes, IFeatureScopeSession featureScopeSession, JvmMember member, /* @Nullable */ XExpression expression, boolean returnType) { if (expression != null) { markToBeInferred(resolvedTypes, expression); return new DemandTypeReferenceProvider(member, expression, resolvedTypesByContext, resolvedTypes, featureScopeSession, returnType); } return new AnyTypeReferenceProvider(member, resolvedTypes, this); }
@Override public void applyToComputationState() { state.acceptCandidate(implicit, this); getState().markAsRefinedTypeIfNecessary(this); }
@Override protected ExpressionTypeComputationState createExpressionComputationState(XExpression expression, StackedResolvedTypes typeResolution) { return new RootExpressionTypeComputationState(typeResolution, getFeatureScopeSession(), this, expression, getExpectedType()); }
@Override public ITypeComputationState assignType(JvmIdentifiableElement element, /* @Nullable */ LightweightTypeReference type) { AbstractTypeComputationState[] result = new AbstractTypeComputationState[components.length]; for (int i = 0; i < components.length; i++) { result[i] = components[i].assignType(element, type); } return new CompoundTypeComputationState(owner, result); }
/** * Returns the current severity for the given issue code. */ protected Severity getSeverity(String issueCode) { return getState().getSeverity(issueCode); }
protected void unmarkComputing(JvmTypeReference knownType) { AbstractDemandTypeReferenceProvider demandTypeReferenceProvider = getComputedTypeReference(knownType); if (demandTypeReferenceProvider != null) { demandTypeReferenceProvider.unmarkComputing(); } }
protected CandidateCompareResult compareTo(AbstractPendingLinkingCandidate<?> right) { Candidate primaryCandidate = getPrimaryCandidate(); CandidateCompareResult result = primaryCandidate.compareTo(right); return result; }
@Override protected LightweightTypeReference acceptType(XExpression alreadyHandled, ResolvedTypes types, AbstractTypeExpectation expectation, LightweightTypeReference type, boolean returnType, int flags) { return getParent().acceptType(alreadyHandled, types, expectation, type, returnType, flags); }
/** * For testing purpose */ protected List<XExpression> getSyntacticArguments() { return helper.getSyntacticArguments(getFeatureCall()); }
protected LightweightTypeReference doGetReturnType(XExpression expression, boolean onlyExplicitReturn) { TypeData typeData = getTypeData(expression, true, onlyExplicitReturn); if (typeData != null) return typeData.getActualType(); return null; }