Examples with TypeSameAsType com.github.javaparser.symbolsolver.resolution.typeinference.constraintformulas.TypeSameAsType used on opensource projects

Example 1 with TypeSameAsType

use of com.github.javaparser.symbolsolver.resolution.typeinference.constraintformulas.TypeSameAsType in project javaparser by javaparser.

the class BoundSet method deriveImpliedBounds.

public BoundSet deriveImpliedBounds(TypeSolver typeSolver) {
    // As bound sets are constructed and grown during inference, it is possible that new bounds can be inferred
    // based on the assertions of the original bounds. The process of incorporation identifies these new bounds
    // and adds them to the bound set.
    // 
    // Incorporation can happen in two scenarios. One scenario is that the bound set contains complementary pairs
    // of bounds; this implies new constraint formulas, as specified in §18.3.1. The other scenario is that the
    // bound set contains a bound involving capture conversion; this implies new bounds and may imply new
    // constraint formulas, as specified in §18.3.2. In both scenarios, any new constraint formulas are reduced,
    // and any new bounds are added to the bound set. This may trigger further incorporation; ultimately, the set
    // will reach a fixed point and no further bounds can be inferred.
    // 
    // If incorporation of a bound set has reached a fixed point, and the set does not contain the bound false,
    // then the bound set has the following properties:
    // 
    // - For each combination of a proper lower bound L and a proper upper bound U of an inference variable, L <: U.
    // 
    // - If every inference variable mentioned by a bound has an instantiation, the bound is satisfied by the
    // corresponding substitution.
    // 
    // - Given a dependency α = β, every bound of α matches a bound of β, and vice versa.
    // 
    // - Given a dependency α <: β, every lower bound of α is a lower bound of β, and every upper bound of β is an
    // upper bound of α.
    ConstraintFormulaSet newConstraintsSet = ConstraintFormulaSet.empty();
    // SECTION Complementary Pairs of Bounds
    // (In this section, S and T are inference variables or types, and U is a proper type. For conciseness, a bound
    // of the form α = T may also match a bound of the form T = α.)
    // 
    // When a bound set contains a pair of bounds that match one of the following rules, a new constraint formula
    // is implied:
    // 
    // - α = S and α = T imply ‹S = T›
    newConstraintsSet = forEachPairSameAs((a, b, currentConstraintSet) -> {
        if (areSameTypeInference(a.getS(), b.getS())) {
            currentConstraintSet = currentConstraintSet.withConstraint(new TypeSameAsType(a.getT(), b.getT()));
        }
        if (areSameTypeInference(a.getS(), b.getT())) {
            currentConstraintSet = currentConstraintSet.withConstraint(new TypeSameAsType(a.getS(), b.getT()));
        }
        if (areSameTypeInference(a.getT(), b.getS())) {
            currentConstraintSet = currentConstraintSet.withConstraint(new TypeSameAsType(a.getT(), b.getS()));
        }
        if (areSameTypeInference(a.getT(), b.getT())) {
            currentConstraintSet = currentConstraintSet.withConstraint(new TypeSameAsType(a.getS(), b.getS()));
        }
        return currentConstraintSet;
    }, newConstraintsSet);
    // - α = S and α <: T imply ‹S <: T›
    newConstraintsSet = forEachPairSameAndSubtype((a, b, currentConstraintSet) -> {
        if (areSameTypeInference(a.getS(), b.getS())) {
            currentConstraintSet = currentConstraintSet.withConstraint(new TypeSubtypeOfType(typeSolver, a.getT(), b.getT()));
        }
        if (areSameTypeInference(a.getT(), b.getS())) {
            currentConstraintSet = currentConstraintSet.withConstraint(new TypeSubtypeOfType(typeSolver, a.getS(), b.getT()));
        }
        return currentConstraintSet;
    }, newConstraintsSet);
    // - α = S and T <: α imply ‹T <: S›
    newConstraintsSet = forEachPairSameAndSubtype((a, b, currentConstraintSet) -> {
        if (areSameTypeInference(a.getS(), b.getT())) {
            currentConstraintSet = currentConstraintSet.withConstraint(new TypeSubtypeOfType(typeSolver, b.getS(), a.getT()));
        }
        if (areSameTypeInference(a.getT(), b.getT())) {
            currentConstraintSet = currentConstraintSet.withConstraint(new TypeSubtypeOfType(typeSolver, b.getS(), a.getS()));
        }
        return currentConstraintSet;
    }, newConstraintsSet);
    // - S <: α and α <: T imply ‹S <: T›
    newConstraintsSet = forEachPairSubtypeAndSubtype((a, b, currentConstraintSet) -> {
        if (areSameTypeInference(a.getT(), b.getS())) {
            currentConstraintSet = currentConstraintSet.withConstraint(new TypeSubtypeOfType(typeSolver, b.getS(), a.getT()));
        }
        return currentConstraintSet;
    }, newConstraintsSet);
    // - α = U and S = T imply ‹S[α:=U] = T[α:=U]›
    newConstraintsSet = forEachPairSameAs((a, b, currentConstraintSet) -> {
        if (isInferenceVariable(a.getS()) && isProperType(a.getT())) {
            InferenceVariable alpha = (InferenceVariable) a.getS();
            ResolvedType U = a.getT();
            ResolvedType S = b.getS();
            ResolvedType T = b.getT();
            Substitution sub = Substitution.empty().withPair(alpha.getTypeParameterDeclaration(), U);
            currentConstraintSet = currentConstraintSet.withConstraint(new TypeSameAsType(sub.apply(S), sub.apply(T)));
        }
        if (isInferenceVariable(a.getT()) && isProperType(a.getS())) {
            InferenceVariable alpha = (InferenceVariable) a.getT();
            ResolvedType U = a.getS();
            ResolvedType S = b.getS();
            ResolvedType T = b.getT();
            Substitution sub = Substitution.empty().withPair(alpha.getTypeParameterDeclaration(), U);
            currentConstraintSet = currentConstraintSet.withConstraint(new TypeSameAsType(sub.apply(S), sub.apply(T)));
        }
        if (isInferenceVariable(b.getS()) && isProperType(b.getT())) {
            InferenceVariable alpha = (InferenceVariable) b.getS();
            ResolvedType U = b.getT();
            ResolvedType S = a.getS();
            ResolvedType T = a.getT();
            Substitution sub = Substitution.empty().withPair(alpha.getTypeParameterDeclaration(), U);
            currentConstraintSet = currentConstraintSet.withConstraint(new TypeSameAsType(sub.apply(S), sub.apply(T)));
        }
        if (isInferenceVariable(b.getT()) && isProperType(b.getS())) {
            InferenceVariable alpha = (InferenceVariable) b.getT();
            ResolvedType U = b.getS();
            ResolvedType S = a.getS();
            ResolvedType T = a.getT();
            Substitution sub = Substitution.empty().withPair(alpha.getTypeParameterDeclaration(), U);
            currentConstraintSet = currentConstraintSet.withConstraint(new TypeSameAsType(sub.apply(S), sub.apply(T)));
        }
        return currentConstraintSet;
    }, newConstraintsSet);
    // - α = U and S <: T imply ‹S[α:=U] <: T[α:=U]›
    newConstraintsSet = forEachPairSameAndSubtype((a, b, currentConstraintSet) -> {
        if (isInferenceVariable(a.getS()) && isProperType(a.getT())) {
            InferenceVariable alpha = (InferenceVariable) a.getS();
            ResolvedType U = a.getT();
            ResolvedType S = b.getS();
            ResolvedType T = b.getT();
            Substitution sub = Substitution.empty().withPair(alpha.getTypeParameterDeclaration(), U);
            currentConstraintSet = currentConstraintSet.withConstraint(new TypeSubtypeOfType(typeSolver, sub.apply(S), sub.apply(T)));
        }
        if (isInferenceVariable(a.getT()) && isProperType(a.getS())) {
            InferenceVariable alpha = (InferenceVariable) a.getT();
            ResolvedType U = a.getS();
            ResolvedType S = b.getS();
            ResolvedType T = b.getT();
            Substitution sub = Substitution.empty().withPair(alpha.getTypeParameterDeclaration(), U);
            currentConstraintSet = currentConstraintSet.withConstraint(new TypeSubtypeOfType(typeSolver, sub.apply(S), sub.apply(T)));
        }
        return currentConstraintSet;
    }, newConstraintsSet);
    // When a bound set contains a pair of bounds α <: S and α <: T, and there exists a supertype of S of the
    // form G<S1, ..., Sn> and a supertype of T of the form G<T1, ..., Tn> (for some generic class or interface, G),
    // then for all i (1 ≤ i ≤ n), if Si and Ti are types (not wildcards), the constraint formula ‹Si = Ti› is
    // implied.
    newConstraintsSet = forEachPairSubtypeAndSubtype((a, b, currentConstraintSet) -> {
        if (isInferenceVariable(a.getS()) && isInferenceVariable(b.getS())) {
            if (a.getT().isReferenceType() && b.getT().isReferenceType()) {
                ResolvedReferenceType S = a.getT().asReferenceType();
                ResolvedReferenceType T = b.getT().asReferenceType();
                List<Pair<ResolvedReferenceType, ResolvedReferenceType>> pairs = findPairsOfCommonAncestors(S, T);
                for (Pair<ResolvedReferenceType, ResolvedReferenceType> pair : pairs) {
                    for (int i = 0; i < Math.min(pair.a.typeParametersValues().size(), pair.b.typeParametersValues().size()); i++) {
                        ResolvedType si = pair.a.typeParametersValues().get(i);
                        ResolvedType ti = pair.b.typeParametersValues().get(i);
                        if (!si.isWildcard() && !ti.isWildcard()) {
                            currentConstraintSet = currentConstraintSet.withConstraint(new TypeSameAsType(si, ti));
                        }
                    }
                }
            }
        }
        return currentConstraintSet;
    }, newConstraintsSet);
    for (Bound b : this.bounds.stream().filter(b -> b instanceof CapturesBound).collect(Collectors.toList())) {
        CapturesBound capturesBound = (CapturesBound) b;
        throw new UnsupportedOperationException();
    // Let P1, ..., Pn represent the type parameters of G and let B1, ..., Bn represent the bounds of these type
    // parameters. Let θ represent the substitution [P1:=α1, ..., Pn:=αn]. Let R be a type that is not an inference
    // variable (but is not necessarily a proper type).
    // 
    // A set of bounds on α1, ..., αn is implied, constructed from the declared bounds of P1, ..., Pn as specified
    // in §18.1.3.
    // 
    // In addition, for all i (1 ≤ i ≤ n):
    // 
    // - If Ai is not a wildcard, then the bound αi = Ai is implied.
    // 
    // - If Ai is a wildcard of the form ?:
    // 
    // - αi = R implies the bound false
    // 
    // - αi <: R implies the constraint formula ‹Bi θ <: R›
    // 
    // - R <: αi implies the bound false
    // 
    // - If Ai is a wildcard of the form ? extends T:
    // 
    // - αi = R implies the bound false
    // 
    // - If Bi is Object, then αi <: R implies the constraint formula ‹T <: R›
    // 
    // - If T is Object, then αi <: R implies the constraint formula ‹Bi θ <: R›
    // 
    // - R <: αi implies the bound false
    // 
    // - If Ai is a wildcard of the form ? super T:
    // 
    // - αi = R implies the bound false
    // 
    // - αi <: R implies the constraint formula ‹Bi θ <: R›
    // 
    // - R <: αi implies the constraint formula ‹R <: T›
    }
    if (newConstraintsSet.isEmpty()) {
        return this;
    } else {
        BoundSet newBounds = newConstraintsSet.reduce(typeSolver);
        if (newBounds.isEmpty()) {
            return this;
        }
        return this.incorporate(newBounds, typeSolver);
    }
}