Examples with RuleEnvironment org.eclipse.xsemantics.runtime.RuleEnvironment used on opensource projects

Example 1 with RuleEnvironment

use of org.eclipse.xsemantics.runtime.RuleEnvironment in project n4js by eclipse.

the class N4JSEnumValidator method checkUsageOfStringBasedEnum.

/**
 * See N4JS Specification, Req. IDE-41, Nr. 6.
 */
@Check
public void checkUsageOfStringBasedEnum(IdentifierRef identRef) {
    final IdentifiableElement id = identRef.getId();
    if (id == null || id.eIsProxy()) {
        return;
    }
    if (!(id instanceof TEnum)) {
        return;
    }
    final TEnum tEnum = (TEnum) id;
    if (!AnnotationDefinition.STRING_BASED.hasAnnotation(tEnum)) {
        return;
    }
    // we now have an IdentifierRef pointing to a string-based enum ...
    final EObject parent = N4JSASTUtils.skipParenExpressionUpward(identRef.eContainer());
    final ParameterizedPropertyAccessExpression parentPAE = parent instanceof ParameterizedPropertyAccessExpression ? (ParameterizedPropertyAccessExpression) parent : null;
    final IdentifiableElement prop = parentPAE != null ? parentPAE.getProperty() : null;
    if (prop != null) {
        if (prop.eIsProxy()) {
            // unnecessary duplicate error
            return;
        }
        if (tEnum.getLiterals().contains(prop)) {
            // reference to one of tEnum's literals -> valid usage!
            return;
        }
        final RuleEnvironment G = RuleEnvironmentExtensions.newRuleEnvironment(identRef);
        final TMember getterLiterals = RuleEnvironmentExtensions.n4StringBasedEnumType(G).findOwnedMember("literals", false, true);
        if (prop == getterLiterals) {
            // reference to static getter 'literals' in N4StringBasedEnum -> valid usage!
            return;
        }
    }
    // invalid usage!
    addIssue(getMessageForENM_INVALID_USE_OF_STRINGBASED_ENUM(), identRef, ENM_INVALID_USE_OF_STRINGBASED_ENUM);
}

Example 2 with RuleEnvironment

use of org.eclipse.xsemantics.runtime.RuleEnvironment in project n4js by eclipse.

the class N4JSMemberRedefinitionValidator method isSubTypeResult.

/**
 * @param rightThisContextType
 *            the type to use as context for the "this binding" of the right-hand-side member or <code>null</code>
 *            to use the default, i.e. the {@link #getCurrentTypeContext() current type context}.
 */
private Result<Boolean> isSubTypeResult(TMember left, Type rightThisContextType, TMember right) {
    // will return type of value for fields, function type for methods, type of return value for getters, type of
    // parameter for setters
    final Resource res = left.eResource();
    final TypeRef mainContext = getCurrentTypeContext();
    final TypeRef rightThisContext = rightThisContextType != null ? TypeUtils.createTypeRef(rightThisContextType) : mainContext;
    final RuleEnvironment G_left = ts.createRuleEnvironmentForContext(mainContext, mainContext, res);
    final RuleEnvironment G_right = ts.createRuleEnvironmentForContext(mainContext, rightThisContext, res);
    TypeRef typeLeft = ts.tau(left, G_left);
    TypeRef typeRight = ts.tau(right, G_right);
    // in case of checking compatibility of constructors, we can ignore the return types
    // i.e. turn {function(string):this[C]?} into {function(string)}
    // (simplifies subtype check and, more importantly, leads to better error messages)
    RuleEnvironment G = getCurrentRuleEnvironment();
    if (left.isConstructor() && typeLeft instanceof FunctionTypeExprOrRef) {
        typeLeft = changeReturnTypeToVoid(G, (FunctionTypeExprOrRef) typeLeft);
    }
    if (right.isConstructor() && typeRight instanceof FunctionTypeExprOrRef) {
        typeRight = changeReturnTypeToVoid(G, (FunctionTypeExprOrRef) typeRight);
    }
    return ts.subtype(G, typeLeft, typeRight);
}

Example 3 with RuleEnvironment

use of org.eclipse.xsemantics.runtime.RuleEnvironment in project n4js by eclipse.

the class Reducer method isSubtypeOf.

/**
 * Convenience method to perform subtype checks. Depending on the given variance, this will check
 * <code>left &lt;: right</code> OR <code>left >: right</code> OR both.
 */
private boolean isSubtypeOf(TypeRef left, TypeRef right, Variance variance) {
    // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    // recursion guard
    final Pair<String, Pair<TypeRef, TypeRef>> key = Pair.of(RuleEnvironmentExtensions.GUARD_REDUCER_IS_SUBTYPE_OF, Pair.of(left, right));
    if (G.get(key) != null) {
        return true;
    }
    final RuleEnvironment G2 = RuleEnvironmentExtensions.wrap(G);
    G2.add(key, Boolean.TRUE);
    // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    switch(variance) {
        case CO:
            return ts.subtypeSucceeded(G2, left, right);
        case CONTRA:
            return ts.subtypeSucceeded(G2, right, left);
        case INV:
            return ts.equaltypeSucceeded(G2, left, right);
    }
    // actually unreachable, each case above returns
    throw new IllegalStateException("unreachable");
}

Example 4 with RuleEnvironment

use of org.eclipse.xsemantics.runtime.RuleEnvironment in project n4js by eclipse.

the class InternalTypeSystem method applyRuleSubtypeTypeTypeRef.

protected Result<Boolean> applyRuleSubtypeTypeTypeRef(final RuleEnvironment G, final RuleApplicationTrace _trace_, final TypeTypeRef left, final TypeTypeRef right) throws RuleFailedException {
    final TypeArgument leftTypeArg = left.getTypeArg();
    final TypeArgument rightTypeArg = right.getTypeArg();
    final boolean leftIsCtorRef = left.isConstructorRef();
    final boolean rightIsCtorRef = right.isConstructorRef();
    final boolean rightHasTypeRef = (rightTypeArg instanceof TypeRef);
    if (((!leftIsCtorRef) && rightIsCtorRef)) {
        /* fail */
        throwForExplicitFail();
    } else {
        if ((rightHasTypeRef && (!rightIsCtorRef))) {
            /* G |- leftTypeArg <: rightTypeArg */
            subtypeInternal(G, _trace_, leftTypeArg, rightTypeArg);
        } else {
            if ((rightHasTypeRef && rightIsCtorRef)) {
                final Type left_staticType = this.typeSystemHelper.getStaticType(G, left);
                final Type right_staticType = this.typeSystemHelper.getStaticType(G, right);
                final boolean leftHasCovariantConstructor = ((left_staticType instanceof TClassifier) && N4JSLanguageUtils.hasCovariantConstructor(((TClassifier) left_staticType)));
                /* !(leftTypeArg instanceof Wildcard || leftTypeArg instanceof ExistentialTypeRef || leftTypeArg instanceof ThisTypeRef) || leftHasCovariantConstructor */
                if (!((!(((leftTypeArg instanceof Wildcard) || (leftTypeArg instanceof ExistentialTypeRef)) || (leftTypeArg instanceof ThisTypeRef))) || leftHasCovariantConstructor)) {
                    sneakyThrowRuleFailedException("!(leftTypeArg instanceof Wildcard || leftTypeArg instanceof ExistentialTypeRef || leftTypeArg instanceof ThisTypeRef) || leftHasCovariantConstructor");
                }
                /* G |- leftTypeArg <: rightTypeArg */
                subtypeInternal(G, _trace_, leftTypeArg, rightTypeArg);
                if (((left_staticType instanceof TypeVariable) || (right_staticType instanceof TypeVariable))) {
                    /* left_staticType === right_staticType */
                    if (!(left_staticType == right_staticType)) {
                        sneakyThrowRuleFailedException("left_staticType === right_staticType");
                    }
                } else {
                    final TMethod leftCtor = this.containerTypesHelper.fromContext(RuleEnvironmentExtensions.getContextResource(G)).findConstructor(((ContainerType<?>) left_staticType));
                    final TMethod rightCtor = this.containerTypesHelper.fromContext(RuleEnvironmentExtensions.getContextResource(G)).findConstructor(((ContainerType<?>) right_staticType));
                    /* leftCtor!==null && rightCtor!==null */
                    if (!((leftCtor != null) && (rightCtor != null))) {
                        sneakyThrowRuleFailedException("leftCtor!==null && rightCtor!==null");
                    }
                    /* G |- leftCtor : var TypeRef leftCtorRef */
                    TypeRef leftCtorRef = null;
                    Result<TypeRef> result = typeInternal(G, _trace_, leftCtor);
                    checkAssignableTo(result.getFirst(), TypeRef.class);
                    leftCtorRef = (TypeRef) result.getFirst();
                    /* G |- rightCtor : var TypeRef rightCtorRef */
                    TypeRef rightCtorRef = null;
                    Result<TypeRef> result_1 = typeInternal(G, _trace_, rightCtor);
                    checkAssignableTo(result_1.getFirst(), TypeRef.class);
                    rightCtorRef = (TypeRef) result_1.getFirst();
                    final RuleEnvironment G_left = RuleEnvironmentExtensions.wrap(G);
                    final RuleEnvironment G_right = RuleEnvironmentExtensions.wrap(G);
                    this.typeSystemHelper.addSubstitutions(G_left, TypeExtensions.ref(left_staticType));
                    RuleEnvironmentExtensions.addThisType(G_left, TypeExtensions.ref(left_staticType));
                    this.typeSystemHelper.addSubstitutions(G_right, TypeExtensions.ref(right_staticType));
                    RuleEnvironmentExtensions.addThisType(G_right, TypeExtensions.ref(right_staticType));
                    /* G_left |- leftCtorRef ~> var TypeRef leftCtorRefSubst */
                    TypeRef leftCtorRefSubst = null;
                    Result<TypeArgument> result_2 = substTypeVariablesInternal(G_left, _trace_, leftCtorRef);
                    checkAssignableTo(result_2.getFirst(), TypeRef.class);
                    leftCtorRefSubst = (TypeRef) result_2.getFirst();
                    /* G_right |- rightCtorRef ~> var TypeRef rightCtorRefSubst */
                    TypeRef rightCtorRefSubst = null;
                    Result<TypeArgument> result_3 = substTypeVariablesInternal(G_right, _trace_, rightCtorRef);
                    checkAssignableTo(result_3.getFirst(), TypeRef.class);
                    rightCtorRefSubst = (TypeRef) result_3.getFirst();
                    /* G |- leftCtorRefSubst <: rightCtorRefSubst */
                    subtypeInternal(G, _trace_, leftCtorRefSubst, rightCtorRefSubst);
                }
            } else {
                /* G |~ leftTypeArg /\ var TypeRef upperBoundLeft */
                TypeRef upperBoundLeft = null;
                Result<TypeRef> result_4 = upperBoundInternal(G, _trace_, leftTypeArg);
                checkAssignableTo(result_4.getFirst(), TypeRef.class);
                upperBoundLeft = (TypeRef) result_4.getFirst();
                /* G |~ leftTypeArg \/ var TypeRef lowerBoundLeft */
                TypeRef lowerBoundLeft = null;
                Result<TypeRef> result_5 = lowerBoundInternal(G, _trace_, leftTypeArg);
                checkAssignableTo(result_5.getFirst(), TypeRef.class);
                lowerBoundLeft = (TypeRef) result_5.getFirst();
                /* G |~ rightTypeArg /\ var TypeRef upperBoundRight */
                TypeRef upperBoundRight = null;
                Result<TypeRef> result_6 = upperBoundInternal(G, _trace_, rightTypeArg);
                checkAssignableTo(result_6.getFirst(), TypeRef.class);
                upperBoundRight = (TypeRef) result_6.getFirst();
                /* G |~ rightTypeArg \/ var TypeRef lowerBoundRight */
                TypeRef lowerBoundRight = null;
                Result<TypeRef> result_7 = lowerBoundInternal(G, _trace_, rightTypeArg);
                checkAssignableTo(result_7.getFirst(), TypeRef.class);
                lowerBoundRight = (TypeRef) result_7.getFirst();
                /* G |- upperBoundLeft <: upperBoundRight */
                subtypeInternal(G, _trace_, upperBoundLeft, upperBoundRight);
                /* G |- lowerBoundRight <: lowerBoundLeft */
                subtypeInternal(G, _trace_, lowerBoundRight, lowerBoundLeft);
            }
        }
    }
    return new Result<Boolean>(true);
}

Example 5 with RuleEnvironment

use of org.eclipse.xsemantics.runtime.RuleEnvironment in project n4js by eclipse.

the class InternalTypeSystem method applyRuleSubtypeParameterizedTypeRef.

protected Result<Boolean> applyRuleSubtypeParameterizedTypeRef(final RuleEnvironment G, final RuleApplicationTrace _trace_, final ParameterizedTypeRef leftOriginal, final ParameterizedTypeRef rightOriginal) throws RuleFailedException {
    final TypeRef left = RuleEnvironmentExtensions.getReplacement(G, leftOriginal);
    final TypeRef right = RuleEnvironmentExtensions.getReplacement(G, rightOriginal);
    final Type leftDeclType = left.getDeclaredType();
    final Type rightDeclType = right.getDeclaredType();
    if (((leftDeclType == null) || (rightDeclType == null))) {
        /* true */
        if (!true) {
            sneakyThrowRuleFailedException("true");
        }
    } else {
        if ((leftDeclType.eIsProxy() || rightDeclType.eIsProxy())) {
            /* true */
            if (!true) {
                sneakyThrowRuleFailedException("true");
            }
        } else {
            if (((leftDeclType instanceof VoidType) || (rightDeclType instanceof VoidType))) {
                /* leftDeclType instanceof VoidType && rightDeclType instanceof VoidType */
                if (!((leftDeclType instanceof VoidType) && (rightDeclType instanceof VoidType))) {
                    sneakyThrowRuleFailedException("leftDeclType instanceof VoidType && rightDeclType instanceof VoidType");
                }
            } else {
                if ((((leftDeclType instanceof UndefinedType) || ((leftDeclType instanceof NullType) && (!(rightDeclType instanceof UndefinedType)))) || (rightDeclType instanceof AnyType))) {
                    /* true */
                    if (!true) {
                        sneakyThrowRuleFailedException("true");
                    }
                } else {
                    if ((((leftDeclType == RuleEnvironmentExtensions.intType(G)) && (rightDeclType == RuleEnvironmentExtensions.numberType(G))) || ((leftDeclType == RuleEnvironmentExtensions.numberType(G)) && (rightDeclType == RuleEnvironmentExtensions.intType(G))))) {
                        /* true */
                        if (!true) {
                            sneakyThrowRuleFailedException("true");
                        }
                    } else {
                        if (((leftDeclType instanceof TEnum) && ((rightDeclType == RuleEnvironmentExtensions.n4EnumType(G)) || (rightDeclType == RuleEnvironmentExtensions.objectType(G))))) {
                            boolean _hasAnnotation = AnnotationDefinition.STRING_BASED.hasAnnotation(leftDeclType);
                            /* !AnnotationDefinition.STRING_BASED.hasAnnotation( leftDeclType ) */
                            if (!(!_hasAnnotation)) {
                                sneakyThrowRuleFailedException("!AnnotationDefinition.STRING_BASED.hasAnnotation( leftDeclType )");
                            }
                        } else {
                            if (((leftDeclType instanceof TEnum) && (((rightDeclType == RuleEnvironmentExtensions.n4StringBasedEnumType(G)) || (rightDeclType == RuleEnvironmentExtensions.stringType(G))) || (rightDeclType == RuleEnvironmentExtensions.stringObjectType(G))))) {
                                /* AnnotationDefinition.STRING_BASED.hasAnnotation( leftDeclType ) */
                                if (!AnnotationDefinition.STRING_BASED.hasAnnotation(leftDeclType)) {
                                    sneakyThrowRuleFailedException("AnnotationDefinition.STRING_BASED.hasAnnotation( leftDeclType )");
                                }
                            } else {
                                if (((leftDeclType == RuleEnvironmentExtensions.n4StringBasedEnumType(G)) && ((rightDeclType == RuleEnvironmentExtensions.stringType(G)) || (rightDeclType == RuleEnvironmentExtensions.stringObjectType(G))))) {
                                    /* true */
                                    if (!true) {
                                        sneakyThrowRuleFailedException("true");
                                    }
                                } else {
                                    if (((leftDeclType instanceof PrimitiveType) && (((PrimitiveType) leftDeclType).getAssignmentCompatible() == rightDeclType))) {
                                        /* true */
                                        if (!true) {
                                            sneakyThrowRuleFailedException("true");
                                        }
                                    } else {
                                        if (((rightDeclType instanceof PrimitiveType) && (leftDeclType == ((PrimitiveType) rightDeclType).getAssignmentCompatible()))) {
                                            /* true */
                                            if (!true) {
                                                sneakyThrowRuleFailedException("true");
                                            }
                                        } else {
                                            if (((((leftDeclType instanceof TInterface) && (!(rightDeclType instanceof TInterface))) && Objects.equal(right.getTypingStrategy(), TypingStrategy.NOMINAL)) && (!(((rightDeclType == RuleEnvironmentExtensions.n4ObjectType(G)) || (rightDeclType == RuleEnvironmentExtensions.objectType(G))) || (rightDeclType == RuleEnvironmentExtensions.anyType(G)))))) {
                                                /* false */
                                                if (!false) {
                                                    sneakyThrowRuleFailedException("false");
                                                }
                                            } else {
                                                boolean structuralTyping = false;
                                                boolean _isUseSiteStructuralTyping = right.isUseSiteStructuralTyping();
                                                if (_isUseSiteStructuralTyping) {
                                                    final StructuralTypingResult result = this.typeSystemHelper.isStructuralSubtype(G, left, right);
                                                    boolean _isValue = result.isValue();
                                                    boolean _not = (!_isValue);
                                                    if (_not) {
                                                        /* fail error result.message data PRIORITY_ERROR */
                                                        String _message = result.getMessage();
                                                        String error = _message;
                                                        Object data = TypeSystemErrorExtensions.PRIORITY_ERROR;
                                                        throwForExplicitFail(error, new ErrorInformation(null, null, data));
                                                    }
                                                    structuralTyping = true;
                                                } else {
                                                    boolean _isDefSiteStructuralTyping = right.isDefSiteStructuralTyping();
                                                    if (_isDefSiteStructuralTyping) {
                                                        Pair<TypeRef, TypeRef> _mappedTo = Pair.<TypeRef, TypeRef>of(left, right);
                                                        Pair<String, Pair<TypeRef, TypeRef>> _mappedTo_1 = Pair.<String, Pair<TypeRef, TypeRef>>of(RuleEnvironmentExtensions.GUARD_SUBTYPE_PARAMETERIZED_TYPE_REF__STRUCT, _mappedTo);
                                                        Object _get = G.get(_mappedTo_1);
                                                        final Boolean guard = ((Boolean) _get);
                                                        if (((guard == null) || (!(guard).booleanValue()))) {
                                                            final StructuralTypingResult result_1 = this.typeSystemHelper.isStructuralSubtype(G, left, right);
                                                            boolean _isValue_1 = result_1.isValue();
                                                            boolean _not_1 = (!_isValue_1);
                                                            if (_not_1) {
                                                                boolean _and = false;
                                                                boolean _isN4ObjectOnLeftWithDefSite = result_1.isN4ObjectOnLeftWithDefSite();
                                                                if (!_isN4ObjectOnLeftWithDefSite) {
                                                                    _and = false;
                                                                } else {
                                                                    /* G.wrap, (GUARD_SUBTYPE_PARAMETERIZED_TYPE_REF__STRUCT->(left->right))<-true |- left <: right */
                                                                    RuleEnvironment _wrap = RuleEnvironmentExtensions.wrap(G);
                                                                    Pair<TypeRef, TypeRef> _mappedTo_2 = Pair.<TypeRef, TypeRef>of(left, right);
                                                                    Pair<String, Pair<TypeRef, TypeRef>> _mappedTo_3 = Pair.<String, Pair<TypeRef, TypeRef>>of(RuleEnvironmentExtensions.GUARD_SUBTYPE_PARAMETERIZED_TYPE_REF__STRUCT, _mappedTo_2);
                                                                    boolean _ruleinvocation = subtypeSucceeded(environmentComposition(_wrap, environmentEntry(_mappedTo_3, true)), _trace_, left, right);
                                                                    _and = _ruleinvocation;
                                                                }
                                                                if (_and) {
                                                                    structuralTyping = true;
                                                                } else {
                                                                    /* fail error result.message data PRIORITY_ERROR */
                                                                    String _message_1 = result_1.getMessage();
                                                                    String error_1 = _message_1;
                                                                    Object data_1 = TypeSystemErrorExtensions.PRIORITY_ERROR;
                                                                    throwForExplicitFail(error_1, new ErrorInformation(null, null, data_1));
                                                                }
                                                            }
                                                            structuralTyping = result_1.isValue();
                                                        }
                                                    }
                                                }
                                                if ((!structuralTyping)) {
                                                    if ((((left.isUseSiteStructuralTyping() || left.isDefSiteStructuralTyping()) && (!(Objects.equal(rightDeclType, RuleEnvironmentExtensions.objectType(G)) && (leftDeclType instanceof TClassifier)))) && (!(leftDeclType instanceof PrimitiveType)))) {
                                                        /* fail error "Structural type " + left.typeRefAsString + " is not a subtype of non-structural type " + right.typeRefAsString data PRIORITY_ERROR */
                                                        String _typeRefAsString = left.getTypeRefAsString();
                                                        String _plus = ("Structural type " + _typeRefAsString);
                                                        String _plus_1 = (_plus + " is not a subtype of non-structural type ");
                                                        String _typeRefAsString_1 = right.getTypeRefAsString();
                                                        String _plus_2 = (_plus_1 + _typeRefAsString_1);
                                                        String error_2 = _plus_2;
                                                        Object data_2 = TypeSystemErrorExtensions.PRIORITY_ERROR;
                                                        throwForExplicitFail(error_2, new ErrorInformation(null, null, data_2));
                                                    }
                                                    if (((leftDeclType instanceof TypeVariable) || (rightDeclType instanceof TypeVariable))) {
                                                        boolean _equals = Objects.equal(leftDeclType, rightDeclType);
                                                        if (_equals) {
                                                            /* true */
                                                            if (!true) {
                                                                sneakyThrowRuleFailedException("true");
                                                            }
                                                        } else {
                                                            if ((leftDeclType instanceof TypeVariable)) {
                                                                TypeRef _elvis = null;
                                                                TypeRef _declaredUpperBound = ((TypeVariable) leftDeclType).getDeclaredUpperBound();
                                                                if (_declaredUpperBound != null) {
                                                                    _elvis = _declaredUpperBound;
                                                                } else {
                                                                    TypeRef _typeVariableImplicitUpperBound = N4JSLanguageUtils.getTypeVariableImplicitUpperBound(G);
                                                                    _elvis = _typeVariableImplicitUpperBound;
                                                                }
                                                                final TypeRef ub = _elvis;
                                                                /* G |- ub <: right */
                                                                subtypeInternal(G, _trace_, ub, right);
                                                            } else {
                                                                /* false */
                                                                if (!false) {
                                                                    sneakyThrowRuleFailedException("false");
                                                                }
                                                            }
                                                        }
                                                    } else {
                                                        boolean _equals_1 = Objects.equal(leftDeclType, rightDeclType);
                                                        if (_equals_1) {
                                                            if (((left.getTypeArgs().size() > 0) && (left.getTypeArgs().size() <= right.getTypeArgs().size()))) {
                                                                final int len = Math.min(Math.min(left.getTypeArgs().size(), right.getTypeArgs().size()), rightDeclType.getTypeVars().size());
                                                                for (int i = 0; (i < len); i++) {
                                                                    final TypeArgument leftArg = left.getTypeArgs().get(i);
                                                                    final TypeArgument rightArg = right.getTypeArgs().get(i);
                                                                    final Variance variance = rightDeclType.getVarianceOfTypeVar(i);
                                                                    TypeRef leftArgUpper = null;
                                                                    /* G |~ leftArg /\ leftArgUpper */
                                                                    Result<TypeRef> result_2 = upperBoundInternal(G, _trace_, leftArg);
                                                                    checkAssignableTo(result_2.getFirst(), TypeRef.class);
                                                                    leftArgUpper = (TypeRef) result_2.getFirst();
                                                                    TypeRef leftArgLower = null;
                                                                    /* G |~ leftArg \/ leftArgLower */
                                                                    Result<TypeRef> result_3 = lowerBoundInternal(G, _trace_, leftArg);
                                                                    checkAssignableTo(result_3.getFirst(), TypeRef.class);
                                                                    leftArgLower = (TypeRef) result_3.getFirst();
                                                                    TypeRef rightArgUpper = null;
                                                                    /* G |~ rightArg /\ rightArgUpper */
                                                                    Result<TypeRef> result_4 = upperBoundInternal(G, _trace_, rightArg);
                                                                    checkAssignableTo(result_4.getFirst(), TypeRef.class);
                                                                    rightArgUpper = (TypeRef) result_4.getFirst();
                                                                    TypeRef rightArgLower = null;
                                                                    /* G |~ rightArg \/ rightArgLower */
                                                                    Result<TypeRef> result_5 = lowerBoundInternal(G, _trace_, rightArg);
                                                                    checkAssignableTo(result_5.getFirst(), TypeRef.class);
                                                                    rightArgLower = (TypeRef) result_5.getFirst();
                                                                    RuleEnvironment G2 = null;
                                                                    if (((rightArg instanceof Wildcard) && ((Wildcard) rightArg).isImplicitUpperBoundInEffect())) {
                                                                        Pair<String, TypeArgument> _mappedTo_4 = Pair.<String, TypeArgument>of(RuleEnvironmentExtensions.GUARD_SUBTYPE_PARAMETERIZED_TYPE_REF__ARGS, rightArg);
                                                                        Object _get_1 = G.get(_mappedTo_4);
                                                                        final boolean isGuarded = (_get_1 != null);
                                                                        if ((!isGuarded)) {
                                                                            G2 = RuleEnvironmentExtensions.wrap(G);
                                                                            Pair<String, TypeArgument> _mappedTo_5 = Pair.<String, TypeArgument>of(RuleEnvironmentExtensions.GUARD_SUBTYPE_PARAMETERIZED_TYPE_REF__ARGS, rightArg);
                                                                            /* G2.add(GUARD_SUBTYPE_PARAMETERIZED_TYPE_REF__ARGS->(rightArg), Boolean.TRUE) */
                                                                            if (!G2.add(_mappedTo_5, Boolean.TRUE)) {
                                                                                sneakyThrowRuleFailedException("G2.add(GUARD_SUBTYPE_PARAMETERIZED_TYPE_REF__ARGS->(rightArg), Boolean.TRUE)");
                                                                            }
                                                                        } else {
                                                                            rightArgUpper = RuleEnvironmentExtensions.topTypeRef(G);
                                                                            G2 = G;
                                                                        }
                                                                    } else {
                                                                        G2 = G;
                                                                    }
                                                                    /* { if(variance!=Variance.CONTRA) { G2 |- leftArgUpper <: rightArgUpper } if(variance!=Variance.CO) { G2 |- rightArgLower <: leftArgLower } } or { if(previousFailure.isOrCausedByPriorityError) { fail error stringRep(left) + " is not a subtype of " + stringRep(right) + " due to incompatible type arguments: " + previousFailure.compileMessage data PRIORITY_ERROR } else { fail } } */
                                                                    {
                                                                        RuleFailedException previousFailure = null;
                                                                        try {
                                                                            boolean _notEquals = (!Objects.equal(variance, Variance.CONTRA));
                                                                            if (_notEquals) {
                                                                                /* G2 |- leftArgUpper <: rightArgUpper */
                                                                                subtypeInternal(G2, _trace_, leftArgUpper, rightArgUpper);
                                                                            }
                                                                            boolean _notEquals_1 = (!Objects.equal(variance, Variance.CO));
                                                                            if (_notEquals_1) {
                                                                                /* G2 |- rightArgLower <: leftArgLower */
                                                                                subtypeInternal(G2, _trace_, rightArgLower, leftArgLower);
                                                                            }
                                                                        } catch (Exception e) {
                                                                            previousFailure = extractRuleFailedException(e);
                                                                            boolean _isOrCausedByPriorityError = TypeSystemErrorExtensions.isOrCausedByPriorityError(previousFailure);
                                                                            if (_isOrCausedByPriorityError) {
                                                                                /* fail error stringRep(left) + " is not a subtype of " + stringRep(right) + " due to incompatible type arguments: " + previousFailure.compileMessage data PRIORITY_ERROR */
                                                                                String _stringRep = this.stringRep(left);
                                                                                String _plus_3 = (_stringRep + " is not a subtype of ");
                                                                                String _stringRep_1 = this.stringRep(right);
                                                                                String _plus_4 = (_plus_3 + _stringRep_1);
                                                                                String _plus_5 = (_plus_4 + " due to incompatible type arguments: ");
                                                                                String _compileMessage = TypeSystemErrorExtensions.compileMessage(previousFailure);
                                                                                String _plus_6 = (_plus_5 + _compileMessage);
                                                                                String error_3 = _plus_6;
                                                                                Object data_3 = TypeSystemErrorExtensions.PRIORITY_ERROR;
                                                                                throwForExplicitFail(error_3, new ErrorInformation(null, null, data_3));
                                                                            } else {
                                                                                /* fail */
                                                                                throwForExplicitFail();
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        } else {
                                                            List<ParameterizedTypeRef> _xifexpression = null;
                                                            if ((leftDeclType instanceof ContainerType<?>)) {
                                                                _xifexpression = AllSuperTypeRefsCollector.collect(((ContainerType<?>) leftDeclType));
                                                            } else {
                                                                _xifexpression = CollectionLiterals.<ParameterizedTypeRef>newArrayList();
                                                            }
                                                            final List<ParameterizedTypeRef> allSuperTypeRefs = _xifexpression;
                                                            List<ParameterizedTypeRef> _collectAllImplicitSuperTypes = RuleEnvironmentExtensions.collectAllImplicitSuperTypes(G, left);
                                                            final Iterable<ParameterizedTypeRef> superTypeRefs = Iterables.<ParameterizedTypeRef>concat(allSuperTypeRefs, _collectAllImplicitSuperTypes);
                                                            final Function1<ParameterizedTypeRef, Boolean> _function = (ParameterizedTypeRef it) -> {
                                                                Type _declaredType = it.getDeclaredType();
                                                                return Boolean.valueOf((_declaredType == rightDeclType));
                                                            };
                                                            boolean _exists = IterableExtensions.<ParameterizedTypeRef>exists(superTypeRefs, _function);
                                                            if (_exists) {
                                                                final RuleEnvironment localG_left = RuleEnvironmentExtensions.wrap(G);
                                                                this.typeSystemHelper.addSubstitutions(localG_left, left);
                                                                final Function1<TypeVariable, TypeRef> _function_1 = (TypeVariable it) -> {
                                                                    return TypeExtensions.ref(it);
                                                                };
                                                                final TypeRef syntheticTypeRef = TypeExtensions.ref(rightDeclType, ((TypeArgument[]) Conversions.unwrapArray(ListExtensions.<TypeVariable, TypeRef>map(rightDeclType.getTypeVars(), _function_1), TypeArgument.class)));
                                                                /* localG_left |- syntheticTypeRef ~> var TypeRef effectiveSuperTypeRef */
                                                                TypeRef effectiveSuperTypeRef = null;
                                                                Result<TypeArgument> result_2 = substTypeVariablesInternal(localG_left, _trace_, syntheticTypeRef);
                                                                checkAssignableTo(result_2.getFirst(), TypeRef.class);
                                                                effectiveSuperTypeRef = (TypeRef) result_2.getFirst();
                                                                /* G |- effectiveSuperTypeRef <: right */
                                                                subtypeInternal(G, _trace_, effectiveSuperTypeRef, right);
                                                            } else {
                                                                /* false */
                                                                if (!false) {
                                                                    sneakyThrowRuleFailedException("false");
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    return new Result<Boolean>(true);
}