protected Map<JvmTypeParameter, LightweightMergedBoundTypeArgument> getArgumentTypeParameterMapping() { if (argumentTypeParameterMapping == null) { argumentTypeParameterMapping = Collections.emptyMap(); if (argumentType != null) { argumentTypeParameterMapping = new DeclaratorTypeArgumentCollector().getTypeParameterMapping(argumentType); } } return argumentTypeParameterMapping; }
protected Map<JvmTypeParameter, LightweightMergedBoundTypeArgument> getReceiverTypeParameterMapping() { if (receiverTypeParameterMapping == null) { receiverTypeParameterMapping = Collections.emptyMap(); if (contextType != null) { receiverTypeParameterMapping = new DeclaratorTypeArgumentCollector().getTypeParameterMapping(contextType); } } return receiverTypeParameterMapping; }
protected Map<JvmTypeParameter, LightweightMergedBoundTypeArgument> getReceiverTypeParameterMapping() { if (receiverTypeParameterMapping == null) { receiverTypeParameterMapping = Collections.emptyMap(); if (receiverType != null) { receiverTypeParameterMapping = new DeclaratorTypeArgumentCollector().getTypeParameterMapping(receiverType); } } return receiverTypeParameterMapping; }
public Map<JvmTypeParameter, LightweightMergedBoundTypeArgument> getTypeParameterMapping( ParameterizedTypeReference reference) { DeclaratorTypeArgumentCollector collector = new DeclaratorTypeArgumentCollector(); return collector.getTypeParameterMapping(reference); }
protected TypeParameterSubstitutor<?> createSubstitutor(ITypeReferenceOwner owner, LightweightTypeReference declaringType) { Map<JvmTypeParameter, LightweightMergedBoundTypeArgument> parameterMapping = new DeclaratorTypeArgumentCollector().getTypeParameterMapping(declaringType); StandardTypeParameterSubstitutor substitutor = new StandardTypeParameterSubstitutor(parameterMapping, owner); return substitutor; }
protected TypeParameterSubstitutor<?> createSubstitutor() { DeclaratorTypeArgumentCollector collector = new DeclaratorTypeArgumentCollector() { @Override public Boolean doVisitArrayTypeReference(ArrayTypeReference reference, LightweightTraversalData data) { return reference.getComponentType().accept(this, data); } }; Map<JvmTypeParameter, LightweightMergedBoundTypeArgument> mapping = collector.getTypeParameterMapping(this); UnboundTypeParameterPreservingSubstitutor substitutor = new UnboundTypeParameterPreservingSubstitutor(mapping, getOwner()); return substitutor; }
protected void getAllLocalElements(ExpressionBucket bucket, List<IEObjectDescription> result) { Map<XExpression, LightweightTypeReference> extensionProviders = bucket.getExtensionProviders(); for (Map.Entry<XExpression, LightweightTypeReference> extensionProvider : extensionProviders.entrySet()) { LightweightTypeReference extensionType = extensionProvider.getValue(); Set<JvmFeature> allFeatures = getAllFeatures(extensionType, bucket.getResolvedFeaturesProvider()); if (!allFeatures.isEmpty()) { Map<JvmTypeParameter, LightweightMergedBoundTypeArgument> receiverTypeParameterMapping = new DeclaratorTypeArgumentCollector().getTypeParameterMapping(extensionType); for (JvmFeature feature : allFeatures) { if (!feature.isStatic()) { addDescriptions(feature, extensionProvider.getKey(), extensionType, receiverTypeParameterMapping, bucket, result); } } } } }
@Override protected boolean accept(LightweightTypeReference synonym, int hints) { if (declaringTypeReference.isAssignableFrom(synonym, rawConformanceCheck)) { receiverTypeParameterMapping.set(new DeclaratorTypeArgumentCollector().getTypeParameterMapping(synonym)); return false; } return true; } });
protected Map<JvmTypeParameter, LightweightMergedBoundTypeArgument> computeContextTypeParameterMapping() { if (getDeclaration().isStatic() && !(getDeclaration() instanceof JvmConstructor)) { return Collections.emptyMap(); } return new DeclaratorTypeArgumentCollector().getTypeParameterMapping(getContextType()); }
protected LightweightTypeReference getClosureOperationParameterType(LightweightTypeReference closureType, JvmOperation operation, int i) { ITypeReferenceOwner owner = newTypeReferenceOwner(operation); Map<JvmTypeParameter, LightweightMergedBoundTypeArgument> mapping = new DeclaratorTypeArgumentCollector().getTypeParameterMapping(closureType); LightweightTypeReference parameterType = owner.toLightweightTypeReference(operation.getParameters().get(i).getParameterType()); return new StandardTypeParameterSubstitutor(mapping, owner).substitute(parameterType); }
Map<JvmTypeParameter, LightweightMergedBoundTypeArgument> receiverTypeParameterMapping = new DeclaratorTypeArgumentCollector().getTypeParameterMapping(extensionType); for(JvmFeature feature: allFeatures) { if (!feature.isStatic()) {
protected LightweightTypeReference getClosureOperationReturnType(LightweightTypeReference closureType, JvmOperation operation) { ITypeReferenceOwner owner = newTypeReferenceOwner(operation); Map<JvmTypeParameter, LightweightMergedBoundTypeArgument> mapping = new DeclaratorTypeArgumentCollector().getTypeParameterMapping(closureType); LightweightTypeReference parameterType = owner.toLightweightTypeReference(operation.getReturnType()); return new StandardTypeParameterSubstitutor(mapping, owner).substitute(parameterType); }
if (!getParametersToProcess().contains(constraintType)) { LightweightTypeReference lightweightReference = getOwner().toLightweightTypeReference(constraintReference); Map<JvmTypeParameter, LightweightMergedBoundTypeArgument> constraintParameterMapping = new DeclaratorTypeArgumentCollector().getTypeParameterMapping(lightweightReference); TypeParameterByConstraintSubstitutor substitutor = new TypeParameterByConstraintSubstitutor(constraintParameterMapping, getOwner()); LightweightTypeReference resolvedConstraint = lightweightReference.accept(
@Override public LightweightTypeReference doVisitParameterizedTypeReference(ParameterizedTypeReference reference) { DeclaratorTypeArgumentCollector typeArgumentCollector = new ConstraintAwareTypeArgumentCollector(owner); Map<JvmTypeParameter, LightweightMergedBoundTypeArgument> typeParameterMapping = typeArgumentCollector.getTypeParameterMapping(reference); TypeParameterSubstitutor<?> substitutor = new UnboundTypeParameterPreservingSubstitutor(typeParameterMapping, owner); JvmGenericType iterable = (JvmGenericType) owner.getServices().getTypeReferences().findDeclaredType(Iterable.class, owner.getContextResourceSet()); if (iterable == null) { return owner.newReferenceToObject(); } LightweightTypeReference substituteMe = owner.newParameterizedTypeReference(iterable.getTypeParameters().get(0)); LightweightTypeReference substitutedArgument = substitutor.substitute(substituteMe).getUpperBoundSubstitute(); if (substitutedArgument.getType() instanceof JvmTypeParameter && !(owner.getDeclaredTypeParameters().contains(substitutedArgument.getType()))) { return substitutedArgument.getRawTypeReference(); } return substitutedArgument; }
final TypeConformanceComputationArgument rawConformanceCheck = new TypeConformanceComputationArgument(true, false, false, false, false, false); if (declaringTypeReference.isAssignableFrom(receiverType, rawConformanceCheck)) { receiverTypeParameterMapping.set(new DeclaratorTypeArgumentCollector().getTypeParameterMapping(receiverType)); } else { CommonTypeComputationServices services = receiverType.getOwner().getServices(); receiverTypeParameterMapping.set(new DeclaratorTypeArgumentCollector().getTypeParameterMapping(receiverType));
result.addTypeArgument(substituted); Map<JvmTypeParameter, LightweightMergedBoundTypeArgument> definedMapping = new DeclaratorTypeArgumentCollector().getTypeParameterMapping(result); substitutor.enhanceMapping(definedMapping);