Package com.github.javaparser.symbolsolver.resolution.typeinference

Class LeastUpperBoundLogic

java.lang.Object

com.github.javaparser.symbolsolver.resolution.typeinference.LeastUpperBoundLogic

public class LeastUpperBoundLogic
extends java.lang.Object

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
(package private) static class	LeastUpperBoundLogic.TypeSubstitution

Field Summary

Fields

Modifier and Type	Field	Description
private java.util.Set<java.util.Set<ResolvedType>>	lubCache

Constructor Summary

Constructors

Modifier	Constructor	Description
private	LeastUpperBoundLogic()

Method Summary

Modifier and Type	Method	Description
private ResolvedType	best(java.util.List<ResolvedType> minimalCandidates)
private ResolvedType	bound(ResolvedType type, ResolvedWildcard.BoundType boundType)
private boolean	boundedAsObject(ResolvedTypeParameterDeclaration typeDecl)
private ResolvedType	concreteType(ResolvedType type)
private java.util.List<java.util.Set<ResolvedType>>	erased(java.util.List<java.util.Set<ResolvedType>> typeSets)
private void	filterEnumType(java.util.Set<ResolvedType> resolvedTypes)
private java.util.List<ResolvedType>	intersection(java.util.List<java.util.Set<ResolvedType>> supertypes)
private boolean	isEnum(ResolvedType type)
private boolean	isSubstituable(ResolvedTypeParameterDeclaration typeDecl, ResolvedType type)
private ResolvedType	lcta(ResolvedType type1, ResolvedType type2)
private ResolvedType	lctaBothWildcards(ResolvedWildcard type1, ResolvedWildcard type2)
private ResolvedType	lctaNoWildcard(ResolvedType type1, ResolvedType type2)
private ResolvedType	lctaOneWildcard(ResolvedType rawType, ResolvedWildcard wildcardType)
private ResolvedType	leastContainingParameterization(java.util.List<ResolvedType> types)
private ResolvedType	leastContainingTypeArgument(ResolvedType type1, ResolvedType type2)
ResolvedType	lub(java.util.Set<ResolvedType> types)	See JLS 4.10.4.
private java.util.List<ResolvedType>	minimalCandidates(java.util.List<ResolvedType> erasedCandidates)	Let MEC, the minimal erased candidate set for U1 ...
static LeastUpperBoundLogic	of()
private com.google.common.collect.Multimap<ResolvedType,ResolvedType>	relevantParameterizations(java.util.List<ResolvedType> minimalErasedCandidates, java.util.List<java.util.Set<ResolvedType>> supertypes)	For any element G of MEC that is a generic type, let the "relevant" parameterizations of G, Relevant(G), be: Relevant(G) = { V | 1 ≤ i ≤ k: V in ST(Ui) and V = G<...> }
private ResolvedType	substituteType(ResolvedType type1, LeastUpperBoundLogic.TypeSubstitution typeSubstitution)
private LeastUpperBoundLogic.TypeSubstitution	substitution(java.util.List<Pair<ResolvedTypeParameterDeclaration,ResolvedType>> pairs)
private java.util.Set<ResolvedType>	supertypes(ResolvedReferenceType type)
private java.util.Set<ResolvedType>	supertypes(ResolvedType type)
private java.util.List<java.util.Set<ResolvedType>>	supertypes(java.util.Set<ResolvedType> types)
private java.util.Set<ResolvedType>	toSet(ResolvedType... resolvedTypes)
private java.util.Set<ResolvedType>	union(java.util.List<java.util.Set<ResolvedType>> supertypes)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

lubCache

private java.util.Set<java.util.Set<ResolvedType>> lubCache

Constructor Detail

LeastUpperBoundLogic

private LeastUpperBoundLogic()

Method Detail

of

public static LeastUpperBoundLogic of()

lub

public ResolvedType lub(java.util.Set<ResolvedType> types)

See JLS 4.10.4. Least Upper Bound.

concreteType

private ResolvedType concreteType(ResolvedType type)

isEnum

private boolean isEnum(ResolvedType type)

filterEnumType

private void filterEnumType(java.util.Set<ResolvedType> resolvedTypes)

supertypes

private java.util.List<java.util.Set<ResolvedType>> supertypes(java.util.Set<ResolvedType> types)

supertypes

private java.util.Set<ResolvedType> supertypes(ResolvedType type)

supertypes

private java.util.Set<ResolvedType> supertypes(ResolvedReferenceType type)

erased

private java.util.List<java.util.Set<ResolvedType>> erased(java.util.List<java.util.Set<ResolvedType>> typeSets)

intersection

private java.util.List<ResolvedType> intersection(java.util.List<java.util.Set<ResolvedType>> supertypes)

union

private java.util.Set<ResolvedType> union(java.util.List<java.util.Set<ResolvedType>> supertypes)

minimalCandidates

private java.util.List<ResolvedType> minimalCandidates(java.util.List<ResolvedType> erasedCandidates)

Let MEC, the minimal erased candidate set for U1 ... Uk, be: MEC = { V | V in EC, and for all W != V in EC, it is not the case that W <: V }

Parameters:

erasedCandidates -

Returns:

relevantParameterizations

private com.google.common.collect.Multimap<ResolvedType,ResolvedType> relevantParameterizations(java.util.List<ResolvedType> minimalErasedCandidates,
                                                                                                      java.util.List<java.util.Set<ResolvedType>> supertypes)

For any element G of MEC that is a generic type, let the "relevant" parameterizations of G, Relevant(G), be: Relevant(G) = { V | 1 ≤ i ≤ k: V in ST(Ui) and V = G<...> }

Parameters:

minimalErasedCandidates - MEC

supertypes -

Returns:

the set of known parameterizations for each generic type G of MEC

best

private ResolvedType best(java.util.List<ResolvedType> minimalCandidates)

leastContainingParameterization

private ResolvedType leastContainingParameterization(java.util.List<ResolvedType> types)

leastContainingTypeArgument

private ResolvedType leastContainingTypeArgument(ResolvedType type1,
                                                 ResolvedType type2)

isSubstituable

private boolean isSubstituable(ResolvedTypeParameterDeclaration typeDecl,
                               ResolvedType type)

boundedAsObject

private boolean boundedAsObject(ResolvedTypeParameterDeclaration typeDecl)

substituteType

private ResolvedType substituteType(ResolvedType type1,
                                    LeastUpperBoundLogic.TypeSubstitution typeSubstitution)

substitution

private LeastUpperBoundLogic.TypeSubstitution substitution(java.util.List<Pair<ResolvedTypeParameterDeclaration,ResolvedType>> pairs)

lcta

private ResolvedType lcta(ResolvedType type1,
                          ResolvedType type2)

lctaNoWildcard

private ResolvedType lctaNoWildcard(ResolvedType type1,
                                    ResolvedType type2)

lctaOneWildcard

private ResolvedType lctaOneWildcard(ResolvedType rawType,
                                     ResolvedWildcard wildcardType)

lctaBothWildcards

private ResolvedType lctaBothWildcards(ResolvedWildcard type1,
                                       ResolvedWildcard type2)

bound

private ResolvedType bound(ResolvedType type,
                           ResolvedWildcard.BoundType boundType)

toSet

private java.util.Set<ResolvedType> toSet(ResolvedType... resolvedTypes)