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

Example 31 with ParameterizedTypeRef

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

the class N4ClassDefinitionImpl method getSuperClassifierRefs.

/**
 * <!-- begin-user-doc -->
 * <!-- end-user-doc -->
 * @generated
 */
public Iterable<ParameterizedTypeRef> getSuperClassifierRefs() {
    ParameterizedTypeRef _superClassRef = this.getSuperClassRef();
    EList<ParameterizedTypeRef> _implementedInterfaceRefs = this.getImplementedInterfaceRefs();
    return Iterables.<ParameterizedTypeRef>concat(java.util.Collections.<ParameterizedTypeRef>unmodifiableList(org.eclipse.xtext.xbase.lib.CollectionLiterals.<ParameterizedTypeRef>newArrayList(_superClassRef)), _implementedInterfaceRefs);
}

Example 32 with ParameterizedTypeRef

use of org.eclipse.n4js.ts.typeRefs.ParameterizedTypeRef 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 33 with ParameterizedTypeRef

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

the class AllSuperTypeRefsCollector method doProcess.

@Override
protected void doProcess(ContainerType<?> containerType) {
    if (containerType instanceof TClass) {
        TClass casted = (TClass) containerType;
        ParameterizedTypeRef superType = casted.getSuperClassRef();
        result.addAll(casted.getImplementedInterfaceRefs());
        if (superType != null) {
            result.add(superType);
        }
    } else if (containerType instanceof TInterface) {
        TInterface casted = (TInterface) containerType;
        result.addAll(casted.getSuperInterfaceRefs());
    } else if (containerType instanceof TObjectPrototype) {
        TObjectPrototype casted = (TObjectPrototype) containerType;
        ParameterizedTypeRef superType = casted.getSuperType();
        if (superType != null) {
            result.add(superType);
        }
    } else if (containerType instanceof PrimitiveType) {
        PrimitiveType assignmentCompatible = ((PrimitiveType) containerType).getAssignmentCompatible();
        if (assignmentCompatible != null) {
            ParameterizedTypeRef typeRef = TypeRefsFactory.eINSTANCE.createParameterizedTypeRef();
            typeRef.setDeclaredType(assignmentCompatible);
            result.add(typeRef);
        }
    }
}

Example 34 with ParameterizedTypeRef

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

the class TypeUtils method createResolvedThisTypeRef.

/**
 * Creates the corresponding plain {@link ParameterizedTypeRef} for a given {@link BoundThisTypeRef}. For example,
 * <code>~~this[C]</code> will be turned into <code>~~C</code>.
 */
public static ParameterizedTypeRef createResolvedThisTypeRef(BoundThisTypeRef boundThisTypeRef) {
    if (boundThisTypeRef == null) {
        throw new NullPointerException("Bound this type must not be null!");
    }
    if (boundThisTypeRef.getActualThisTypeRef() == null) {
        throw new NullPointerException("Actual this type of the provided bound this type must not be null!");
    }
    final List<TypeArgument> targsAsList = boundThisTypeRef.getActualThisTypeRef().getTypeArgs();
    final TypeArgument[] targs = targsAsList.toArray(new TypeArgument[targsAsList.size()]);
    final ParameterizedTypeRef resolvedTypeRef = createTypeRef(boundThisTypeRef.getActualThisTypeRef().getDeclaredType(), boundThisTypeRef.getTypingStrategy(), targs);
    if (!boundThisTypeRef.getTypeArgs().isEmpty()) {
        resolvedTypeRef.getTypeArgs().clear();
        resolvedTypeRef.getTypeArgs().addAll(TypeUtils.copyAll(boundThisTypeRef.getTypeArgs()));
    }
    // set structural typing info
    if (resolvedTypeRef instanceof ParameterizedTypeRefStructural)
        copyStructuralTypingInfo((ParameterizedTypeRefStructural) resolvedTypeRef, boundThisTypeRef);
    // copy other properties
    copyTypeModifiers(resolvedTypeRef, boundThisTypeRef);
    return resolvedTypeRef;
}

Example 35 with ParameterizedTypeRef

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

the class TypeUtils method createGeneratorTypeRef.

/**
 * For a given generator function, a return type is created of the form {@code Generator<TYield,TReturn,TNext>} in
 * case no type or a type other than Generator is declared. In case no type is declared, the types TYield and
 * TReturn are inferred from the yield expressions and return statements in the body. The type TNext is
 * <code>any</code>. In case a type other than <code>Generator</code> is declared, type type TYield becomes the
 * declared type. The type TReturn is still inferred from the return statements. In case the declared type is
 * <code>void</code>, both TYield and TReturn become the type <code>undefined</code>.
 *
 * <p>
 * WARNING: this method will resolve proxies in 'successType' (in order to check if it points to type 'void')
 */
public static ParameterizedTypeRef createGeneratorTypeRef(BuiltInTypeScope scope, FunctionDefinition funDef) {
    Objects.requireNonNull(scope);
    Objects.requireNonNull(funDef);
    TypeRef definedReturn = funDef.getReturnTypeRef();
    TypeArgument tYield;
    TypeArgument tReturn = inferReturnTypeFromReturns(funDef, scope);
    if (definedReturn == null) {
        tYield = inferYieldExprTypeFromYields(funDef, scope);
    } else {
        tYield = definedReturn;
        if (TypeUtils.isVoid(definedReturn)) {
            tReturn = scope.getUndefinedTypeRef();
        }
    }
    ParameterizedTypeRef generatorTypeRef = createGeneratorTypeRef(scope, tYield, tReturn, null);
    return generatorTypeRef;
}