Examples with ExistentialTypeRef org.eclipse.n4js.ts.typeRefs.ExistentialTypeRef used on opensource projects

Example 6 with ExistentialTypeRef

use of org.eclipse.n4js.ts.typeRefs.ExistentialTypeRef in project n4js by eclipse.

the class InternalTypeSystem method applyRuleLowerBoundExistentialTypeRef.

protected Result<TypeRef> applyRuleLowerBoundExistentialTypeRef(final RuleEnvironment G, final RuleApplicationTrace _trace_, final ExistentialTypeRef existentialTypeRef) throws RuleFailedException {
    // output parameter
    TypeRef T = null;
    /* G |~ existentialTypeRef.wildcard \/ T */
    Wildcard _wildcard = existentialTypeRef.getWildcard();
    Result<TypeRef> result = lowerBoundInternal(G, _trace_, _wildcard);
    checkAssignableTo(result.getFirst(), TypeRef.class);
    T = (TypeRef) result.getFirst();
    T = TypeUtils.<TypeRef>copy(T);
    TypeUtils.copyTypeModifiers(T, existentialTypeRef);
    return new Result<TypeRef>(T);
}

Example 7 with ExistentialTypeRef

use of org.eclipse.n4js.ts.typeRefs.ExistentialTypeRef in project n4js by eclipse.

the class TypeCompareLogic method compare.

/**
 * WARNING: fqnProvider may be <code>null</code>, but then the lower/greater info will be unreliable!
 */
/* package */
static int compare(IQualifiedNameProvider fqnProvider, TypeArgument arg1, TypeArgument arg2) {
    if (arg1 == arg2) {
        return 0;
    }
    if (arg1 == null) {
        return -1;
    }
    if (arg2 == null) {
        return 1;
    }
    if (arg1 instanceof Wildcard || arg2 instanceof Wildcard) {
        if (arg1 instanceof Wildcard && arg2 instanceof Wildcard) {
            final Wildcard w1 = (Wildcard) arg1;
            final Wildcard w2 = (Wildcard) arg2;
            int c;
            // lower bounds
            c = compare(fqnProvider, w1.getDeclaredLowerBound(), w2.getDeclaredLowerBound());
            if (c != 0) {
                return c;
            }
            // upper bounds
            c = compare(fqnProvider, w1.getDeclaredUpperBound(), w2.getDeclaredUpperBound());
            if (c != 0) {
                return c;
            }
            return 0;
        }
        return compareEClasses(arg1.eClass(), arg2.eClass());
    }
    // now, we know we have two TypeRefs
    final TypeRef ref1 = (TypeRef) arg1;
    final TypeRef ref2 = (TypeRef) arg2;
    // @formatter:on
    if (ref1 instanceof ExistentialTypeRef && ref2 instanceof ExistentialTypeRef) {
        return compare(fqnProvider, ((ExistentialTypeRef) ref1).getWildcard(), ((ExistentialTypeRef) ref2).getWildcard());
    }
    // its subclasses
    if (ref1 instanceof FunctionTypeExprOrRef && ref2 instanceof FunctionTypeExprOrRef) {
        final FunctionTypeExprOrRef f1 = (FunctionTypeExprOrRef) ref1;
        final FunctionTypeExprOrRef f2 = (FunctionTypeExprOrRef) ref2;
        return compareFunctionTypeExprOrRefs(fqnProvider, f1, f2);
    }
    int c;
    c = compareEClasses(ref1.eClass(), ref2.eClass());
    if (c != 0) {
        return c;
    }
    // note: ref1 and ref2 are of the same type, otherwise c would not be 0
    // declared type
    c = compare(fqnProvider, ref1.getDeclaredType(), ref2.getDeclaredType());
    if (c != 0) {
        return c;
    }
    // if we got a subclass of StructuralTypeRef -> check properties of StructuralTypeRef beforehand
    if (ref1 instanceof StructuralTypeRef) {
        final StructuralTypeRef sref1 = (StructuralTypeRef) ref1;
        final StructuralTypeRef sref2 = (StructuralTypeRef) ref2;
        // note: for simplicity, we here require sref1/sref2.structuralMembers to have the same order
        // (we aren't doing a semantic compare anyway)
        c = compareComparables(sref1.getTypingStrategy(), sref2.getTypingStrategy());
        if (c != 0) {
            return c;
        }
        c = compare(fqnProvider, sref1.getStructuralType(), sref2.getStructuralType());
        if (c != 0) {
            return c;
        }
        final Iterator<TStructMember> iter1 = sref1.getStructuralMembers().iterator();
        final Iterator<TStructMember> iter2 = sref2.getStructuralMembers().iterator();
        while (iter1.hasNext() && iter2.hasNext()) {
            c = compareMembers(fqnProvider, iter1.next(), iter2.next());
            if (c != 0) {
                return c;
            }
        }
        if (iter1.hasNext()) {
            return 1;
        }
        if (iter2.hasNext()) {
            return -1;
        }
    }
    if (ref1 instanceof ParameterizedTypeRef) {
        final ParameterizedTypeRef pref1 = (ParameterizedTypeRef) ref1;
        final ParameterizedTypeRef pref2 = (ParameterizedTypeRef) ref2;
        c = compareTypeArguments(fqnProvider, pref1.getTypeArgs(), pref2.getTypeArgs());
        if (c != 0) {
            return c;
        }
    } else if (ref1 instanceof ComposedTypeRef) {
        final ComposedTypeRef cref1 = (ComposedTypeRef) ref1;
        final ComposedTypeRef cref2 = (ComposedTypeRef) ref2;
        c = compareTypeArguments(fqnProvider, cref1.getTypeRefs(), cref2.getTypeRefs());
        if (c != 0) {
            return c;
        }
    } else if (ref1 instanceof TypeTypeRef) {
        final TypeTypeRef cref1 = (TypeTypeRef) ref1;
        final TypeTypeRef cref2 = (TypeTypeRef) ref2;
        c = compareComparables(cref1.isConstructorRef(), cref2.isConstructorRef());
        if (c != 0) {
            return c;
        }
        c = compare(fqnProvider, cref1.getTypeArg(), cref2.getTypeArg());
        if (c != 0) {
            return c;
        }
    } else if (ref1 instanceof BoundThisTypeRef) {
        final BoundThisTypeRef bref1 = (BoundThisTypeRef) ref1;
        final BoundThisTypeRef bref2 = (BoundThisTypeRef) ref2;
        c = compare(fqnProvider, bref1.getActualThisTypeRef(), bref2.getActualThisTypeRef());
        if (c != 0) {
            return c;
        }
    }
    // dynamic
    c = Boolean.compare(ref1.isDynamic(), ref2.isDynamic());
    if (c != 0) {
        return c;
    }
    return 0;
}

Example 8 with ExistentialTypeRef

use of org.eclipse.n4js.ts.typeRefs.ExistentialTypeRef in project n4js by eclipse.

the class TypeUtils method createExistentialTypeRef.

/**
 * Creates a new ExistentialTypeRef.
 */
public static ExistentialTypeRef createExistentialTypeRef(TypeVariable typeVar, Wildcard wildcard) {
    final ExistentialTypeRef etr = TypeRefsFactory.eINSTANCE.createExistentialTypeRef();
    etr.setWildcard(wildcard);
    etr.setBoundTypeVariable(typeVar);
    return etr;
}

Example 9 with ExistentialTypeRef

use of org.eclipse.n4js.ts.typeRefs.ExistentialTypeRef in project n4js by eclipse.

the class InternalTypeSystem method applyRuleSubtypeExistentialTypeRef_Right.

protected Result<Boolean> applyRuleSubtypeExistentialTypeRef_Right(final RuleEnvironment G, final RuleApplicationTrace _trace_, final TypeRef left, final ExistentialTypeRef existentialTypeRef) throws RuleFailedException {
    boolean _isExistentialTypeToBeReopened = RuleEnvironmentExtensions.isExistentialTypeToBeReopened(G, existentialTypeRef);
    if (_isExistentialTypeToBeReopened) {
        final Wildcard wildThing = existentialTypeRef.getWildcard();
        /* G |~ wildThing /\ var TypeRef upperBound */
        TypeRef upperBound = null;
        Result<TypeRef> result = upperBoundInternal(G, _trace_, wildThing);
        checkAssignableTo(result.getFirst(), TypeRef.class);
        upperBound = (TypeRef) result.getFirst();
        /* G |~ wildThing \/ var TypeRef lowerBound */
        TypeRef lowerBound = null;
        Result<TypeRef> result_1 = lowerBoundInternal(G, _trace_, wildThing);
        checkAssignableTo(result_1.getFirst(), TypeRef.class);
        lowerBound = (TypeRef) result_1.getFirst();
        /* G |- left <: upperBound */
        subtypeInternal(G, _trace_, left, upperBound);
        /* G |- lowerBound <: left */
        subtypeInternal(G, _trace_, lowerBound, left);
    } else {
        /* left===existentialTypeRef or { left instanceof ParameterizedTypeRef && (left as ParameterizedTypeRef).declaredType instanceof NullType } or { G |~ existentialTypeRef \/ var TypeRef lowerExt G |- left <: lowerExt } */
        {
            RuleFailedException previousFailure = null;
            try {
                /* left===existentialTypeRef */
                if (!(left == existentialTypeRef)) {
                    sneakyThrowRuleFailedException("left===existentialTypeRef");
                }
            } catch (Exception e) {
                previousFailure = extractRuleFailedException(e);
                /* { left instanceof ParameterizedTypeRef && (left as ParameterizedTypeRef).declaredType instanceof NullType } or { G |~ existentialTypeRef \/ var TypeRef lowerExt G |- left <: lowerExt } */
                {
                    try {
                        /* left instanceof ParameterizedTypeRef && (left as ParameterizedTypeRef).declaredType instanceof NullType */
                        if (!((left instanceof ParameterizedTypeRef) && (((ParameterizedTypeRef) left).getDeclaredType() instanceof NullType))) {
                            sneakyThrowRuleFailedException("left instanceof ParameterizedTypeRef && (left as ParameterizedTypeRef).declaredType instanceof NullType");
                        }
                    } catch (Exception e_1) {
                        previousFailure = extractRuleFailedException(e_1);
                        /* G |~ existentialTypeRef \/ var TypeRef lowerExt */
                        TypeRef lowerExt = null;
                        Result<TypeRef> result_2 = lowerBoundInternal(G, _trace_, existentialTypeRef);
                        checkAssignableTo(result_2.getFirst(), TypeRef.class);
                        lowerExt = (TypeRef) result_2.getFirst();
                        /* G |- left <: lowerExt */
                        subtypeInternal(G, _trace_, left, lowerExt);
                    }
                }
            }
        }
    }
    return new Result<Boolean>(true);
}

Example 10 with ExistentialTypeRef

use of org.eclipse.n4js.ts.typeRefs.ExistentialTypeRef in project n4js by eclipse.

the class InternalTypeSystem method applyRuleSubtypeExistentialTypeRef_Left.

protected Result<Boolean> applyRuleSubtypeExistentialTypeRef_Left(final RuleEnvironment G, final RuleApplicationTrace _trace_, final ExistentialTypeRef existentialTypeRef, final TypeRef right) throws RuleFailedException {
    boolean _isExistentialTypeToBeReopened = RuleEnvironmentExtensions.isExistentialTypeToBeReopened(G, existentialTypeRef);
    if (_isExistentialTypeToBeReopened) {
        final Wildcard wildThing = existentialTypeRef.getWildcard();
        /* G |~ wildThing /\ var TypeRef upperBound */
        TypeRef upperBound = null;
        Result<TypeRef> result = upperBoundInternal(G, _trace_, wildThing);
        checkAssignableTo(result.getFirst(), TypeRef.class);
        upperBound = (TypeRef) result.getFirst();
        /* G |~ wildThing \/ var TypeRef lowerBound */
        TypeRef lowerBound = null;
        Result<TypeRef> result_1 = lowerBoundInternal(G, _trace_, wildThing);
        checkAssignableTo(result_1.getFirst(), TypeRef.class);
        lowerBound = (TypeRef) result_1.getFirst();
        /* G |- right <: upperBound */
        subtypeInternal(G, _trace_, right, upperBound);
        /* G |- lowerBound <: right */
        subtypeInternal(G, _trace_, lowerBound, right);
    } else {
        /* existentialTypeRef===right or { G |~ existentialTypeRef /\ var TypeRef upperExt G |- upperExt <: right } */
        {
            RuleFailedException previousFailure = null;
            try {
                /* existentialTypeRef===right */
                if (!(existentialTypeRef == right)) {
                    sneakyThrowRuleFailedException("existentialTypeRef===right");
                }
            } catch (Exception e) {
                previousFailure = extractRuleFailedException(e);
                /* G |~ existentialTypeRef /\ var TypeRef upperExt */
                TypeRef upperExt = null;
                Result<TypeRef> result_2 = upperBoundInternal(G, _trace_, existentialTypeRef);
                checkAssignableTo(result_2.getFirst(), TypeRef.class);
                upperExt = (TypeRef) result_2.getFirst();
                /* G |- upperExt <: right */
                subtypeInternal(G, _trace_, upperExt, right);
            }
        }
    }
    return new Result<Boolean>(true);
}