protected LightweightTypeReference getAsClassLiteral(final JvmIdentifiableElement feature) { if (feature instanceof JvmType) { final ITypeReferenceOwner owner = state.getReferenceOwner(); return owner.newReferenceTo(Class.class, new TypeReferenceInitializer<ParameterizedTypeReference>() { @Override public LightweightTypeReference enhance(ParameterizedTypeReference reference) { LightweightTypeReference argumentType = owner.newParameterizedTypeReference((JvmType) feature); if (argumentType.isPrimitiveVoid()) { argumentType = owner.newReferenceTo(Void.class); } else { argumentType = argumentType.getWrapperTypeIfPrimitive(); } reference.addTypeArgument(argumentType); return reference; } }); } throw new IllegalArgumentException(String.valueOf(feature)); }
protected List<LightweightTypeReference> getSyntacticTypeArguments() { List<LightweightTypeReference> result = Lists.newArrayList(); List<JvmTypeReference> typeArguments = getPlainSyntacticTypeArguments(); ITypeReferenceOwner referenceOwner = getState().getReferenceOwner(); for(int i = 0, size = typeArguments.size(); i < size; i++) { LightweightTypeReference typeArgument = referenceOwner.toLightweightTypeReference(typeArguments.get(i)); result.add(typeArgument); } return result; }
public List<LightweightTypeReference> getSyntacticTypeArguments() { XConstructorCall constructorCall = getConstructorCall(); List<JvmTypeReference> typeArguments = constructorCall.getTypeArguments(); if (typeArguments.isEmpty()) return Collections.emptyList(); List<LightweightTypeReference> result = Lists.newArrayList(); for(JvmTypeReference typeArgument: typeArguments) { result.add(getState().getReferenceOwner().toLightweightTypeReference(typeArgument)); } return result; }
@Override public List<LightweightTypeReference> getTypeArguments() { XConstructorCall constructorCall = getConstructorCall(); List<JvmTypeReference> typeArguments = constructorCall.getTypeArguments(); if (typeArguments.isEmpty()) return Collections.emptyList(); List<LightweightTypeReference> result = Lists.newArrayList(); for(JvmTypeReference typeArgument: typeArguments) { result.add(getState().getReferenceOwner().toLightweightTypeReference(typeArgument)); } return result; }
@Override public List<LightweightTypeReference> getTypeArguments() { XAbstractFeatureCall featureCall = getFeatureCall(); List<JvmTypeReference> typeArguments = featureCall.getTypeArguments(); if (typeArguments.isEmpty()) return Collections.emptyList(); List<LightweightTypeReference> result = Lists.newArrayList(); for(JvmTypeReference typeArgument: typeArguments) { result.add(getState().getReferenceOwner().toLightweightTypeReference(typeArgument)); } return result; }
@Override public List<LightweightTypeReference> getTypeArguments() { XAbstractFeatureCall featureCall = getFeatureCall(); List<JvmTypeReference> typeArguments = featureCall.getTypeArguments(); if (typeArguments.isEmpty()) return Collections.emptyList(); List<LightweightTypeReference> result = Lists.newArrayList(); for(JvmTypeReference typeArgument: typeArguments) { result.add(getState().getReferenceOwner().toLightweightTypeReference(typeArgument)); } return result; }
protected String getFeatureParameterTypesAsString(JvmExecutable executable) { ITypeReferenceOwner referenceOwner = getState().getReferenceOwner(); List<JvmFormalParameter> parameters = executable.getParameters(); StringBuilder b = new StringBuilder(); b.append("("); for(int i=0; i<parameters.size(); ++i) { JvmTypeReference parameterType = parameters.get(i).getParameterType(); LightweightTypeReference typeReference = referenceOwner.toLightweightTypeReference(parameterType); b.append(typeReference.getHumanReadableName()); if(i < parameters.size()-1) b.append(", "); } b.append(")"); return b.toString(); }
protected void applyType() { state.acceptActualType(state.getReferenceOwner().newUnknownTypeReference(), ConformanceFlags.CHECKED_SUCCESS); }
@Override protected void initializeMapping(JvmTypeParameter typeParameter, Map<JvmTypeParameter, LightweightMergedBoundTypeArgument> result) { ITypeReferenceOwner owner = getState().getReferenceOwner(); if (typeParameter.getDeclarator() instanceof JvmType && owner.getDeclaredTypeParameters().contains(typeParameter)) { LightweightTypeReference typeReference = owner.newParameterizedTypeReference(typeParameter); result.put(typeParameter, new LightweightMergedBoundTypeArgument(typeReference, VarianceInfo.INVARIANT)); } else { super.initializeMapping(typeParameter, result); } }
StringBuilder b = new StringBuilder(); b.append(typeParameter.getName()); ITypeReferenceOwner referenceOwner = getState().getReferenceOwner(); if(!typeParameter.getConstraints().isEmpty()) { boolean firstUpperBound = true;
protected LightweightTypeReference getDeclaredType(JvmIdentifiableElement feature) { LightweightTypeReference result = state.getResolvedTypes().getActualType(feature); if (result == null) { return getState().getReferenceOwner().newAnyTypeReference(); } return result; }
protected boolean isDefiniteEarlyExit(XExpression expression) { CommonTypeComputationServices services = getState().getReferenceOwner().getServices(); return services.getEarlyExitComputer().isDefiniteEarlyExit(expression); }
protected void applyPackageFragment(XMemberFeatureCall memberFeatureCall, JvmDeclaredType type) { XExpression target = memberFeatureCall.getMemberCallTarget(); state.getResolvedTypes().acceptType( target, new NoExpectation(state, false), state.getReferenceOwner().newParameterizedTypeReference(type), false, ConformanceFlags.CHECKED_SUCCESS); if (target instanceof XMemberFeatureCall) { applyPackageFragment((XMemberFeatureCall) target, type); } }
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); } }
protected boolean isCompoundOperator() { if (!(getFeatureCall() instanceof XBinaryOperation)) { return false; } String methodName = getFeature().getSimpleName(); return getState().getReferenceOwner().getServices().getOperatorMapping().isCompoundMethod(methodName); }
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()); } } }
if (parameters.size() == rightParameters.size()) { int result = 0; ITypeReferenceOwner leftReferenceOwner = getState().getReferenceOwner(); ITypeReferenceOwner rightReferenceOwner = right.getState().getReferenceOwner(); TypeParameterByConstraintSubstitutor substitutor = new TypeParameterByConstraintSubstitutor(getDeclaratorParameterMapping(), leftReferenceOwner); TypeParameterByConstraintSubstitutor rightSubstitutor = new TypeParameterByConstraintSubstitutor(right.getDeclaratorParameterMapping(), right.getState().getReferenceOwner()); for(int i = 0; i < parameters.size(); i++) { LightweightTypeReference parameterType = leftReferenceOwner.toLightweightTypeReference(parameters.get(i).getParameterType());
LightweightTypeReference declaredType = arguments.getDeclaredTypeForLambda(idx); if (declaredType != null && !declaredType.isType(Object.class)) { CommonTypeComputationServices services = getState().getReferenceOwner().getServices(); JvmOperation operation = services.getFunctionTypes().findImplementingOperation(declaredType); if (operation == null) {
@Override protected LightweightTypeReference getDeclaredType(JvmIdentifiableElement feature) { if (feature instanceof JvmConstructor) { return getState().getReferenceOwner().toLightweightTypeReference(getState().getTypeReferences().getTypeForName(Void.TYPE, feature));
CommonTypeComputationServices services = getState().getReferenceOwner().getServices(); OperatorMapping operatorMapping = services.getOperatorMapping(); if (operatorMapping.getCompoundOperators().contains(description.getName())) {