public void computeArgumentTypes() { initializeArgumentTypeComputation(); while(arguments.hasUnprocessedArguments()) computeArgumentType(arguments.getNextUnprocessedArgumentSlot()); }
protected void preApply() { computeArgumentTypes(); }
public IFeatureCallArguments createExpressionArguments(XExpression expression, AbstractLinkingCandidate<?> candidate) { JvmIdentifiableElement feature = candidate.getFeature(); if (feature instanceof JvmExecutable) { JvmExecutable executable = (JvmExecutable) feature; return createArgumentsForExecutable(executable.isVarArgs(), candidate.getArguments(), executable.getParameters(), candidate.hasReceiver(), candidate.getState().getReferenceOwner()); } else { if (expression instanceof XAssignment) { XAssignment assignment = (XAssignment) expression; LightweightTypeReference featureType = candidate.getActualType(candidate.getFeature(), true); return new AssignmentFeatureCallArguments(assignment.getValue(), featureType); } else { return new StandardFeatureCallArguments(candidate.getArguments(), Collections.<JvmFormalParameter>emptyList(), candidate.hasReceiver(), candidate.getState().getReferenceOwner()); } } }
@Override public void applyToComputationState() { preApply(); JvmIdentifiableElement feature = getFeature(); LightweightTypeReference featureType = getDeclaredType(feature); if (!isRawTypeContext()) { final Map<JvmTypeParameter, LightweightMergedBoundTypeArgument> declaratorParameterMapping = getDeclaratorParameterMapping(); substitutor = new TypeParameterByUnboundSubstitutor(declaratorParameterMapping, expectation.getReferenceOwner()) { substitutor.enhanceMapping(getTypeParameterMapping()); } else { substitutor = new RawTypeSubstitutor(expectation.getReferenceOwner()); substitutedFeatureType = deferredBindTypeArgument(expectation, substitutedFeatureType);
protected void computeArgumentType(IFeatureCallArgumentSlot slot) { TypeParameterSubstitutor<?> substitutor = createArgumentTypeSubstitutor(); if (!slot.isVarArg() && !slot.isSuperfluous()) { computeFixedArityArgumentType(slot, substitutor); } else if (slot.isVarArg()) { computeVarArgumentType(slot, substitutor); } else { XExpression argument = slot.getArgumentExpression(); if (argument != null) { resolveArgumentType(argument, null, state.withNonVoidExpectation()); } } slot.markProcessed(); }
if (!substitutedComponentType.isAny()) { if (arguments.size() == 1) { ArgumentTypeComputationState first = createVarArgTypeComputationState(substitutedComponentType); ArgumentTypeComputationState second = createLinkingTypeComputationState(arrayTypeReference); argumentState = new CompoundTypeComputationState(substitutedComponentType.getOwner(), first, second); } else { argumentState = createVarArgTypeComputationState(substitutedComponentType); resolveArgumentType(argument, substitutedComponentType, argumentState); for(XExpression argument: arguments) { if (argument != null) { resolveArgumentType(argument, null, state.withNonVoidExpectation());
protected void computeFixedArityArgumentType(IFeatureCallArgumentSlot slot, TypeParameterSubstitutor<?> substitutor) { XExpression argument = slot.getArgumentExpression(); if (argument != null) { LightweightTypeReference parameterType = slot.getDeclaredType(); if (parameterType == null) { parameterType = state.getReferenceOwner().newUnknownTypeReference(); } LightweightTypeReference substitutedParameterType = substitutor.substitute(parameterType); AbstractTypeComputationState argumentState = createLinkingTypeComputationState(substitutedParameterType); resolveArgumentType(argument, substitutedParameterType, argumentState); } }