Examples with TClass org.eclipse.n4js.ts.types.TClass used on opensource projects

Example 6 with TClass

use of org.eclipse.n4js.ts.types.TClass in project n4js by eclipse.

the class InternalTypeSystem method applyRuleTypeAwaitExpression.

protected Result<TypeRef> applyRuleTypeAwaitExpression(final RuleEnvironment G, final RuleApplicationTrace _trace_, final AwaitExpression e) throws RuleFailedException {
    // output parameter
    TypeRef T = null;
    /* G |- e.expression : var TypeRef exprType */
    Expression _expression = e.getExpression();
    TypeRef exprType = null;
    Result<TypeRef> result = typeInternal(G, _trace_, _expression);
    checkAssignableTo(result.getFirst(), TypeRef.class);
    exprType = (TypeRef) result.getFirst();
    Type _declaredType = exprType.getDeclaredType();
    TClass _promiseType = RuleEnvironmentExtensions.promiseType(G);
    boolean _tripleEquals = (_declaredType == _promiseType);
    if (_tripleEquals) {
        /* G |~ exprType.typeArgs.get(0) /\ T */
        TypeArgument _get = exprType.getTypeArgs().get(0);
        Result<TypeRef> result_1 = upperBoundInternal(G, _trace_, _get);
        checkAssignableTo(result_1.getFirst(), TypeRef.class);
        T = (TypeRef) result_1.getFirst();
    } else {
        boolean _isPromisifiableExpression = this.promisifyHelper.isPromisifiableExpression(e.getExpression());
        if (_isPromisifiableExpression) {
            final TypeRef promisifiedReturnTypeRef = this.promisifyHelper.extractPromisifiedReturnType(e.getExpression());
            Type _declaredType_1 = promisifiedReturnTypeRef.getDeclaredType();
            TClass _promiseType_1 = RuleEnvironmentExtensions.promiseType(G);
            boolean _tripleEquals_1 = (_declaredType_1 == _promiseType_1);
            if (_tripleEquals_1) {
                /* G |~ promisifiedReturnTypeRef.typeArgs.get(0) /\ T */
                TypeArgument _get_1 = promisifiedReturnTypeRef.getTypeArgs().get(0);
                Result<TypeRef> result_2 = upperBoundInternal(G, _trace_, _get_1);
                checkAssignableTo(result_2.getFirst(), TypeRef.class);
                T = (TypeRef) result_2.getFirst();
            } else {
                T = promisifiedReturnTypeRef;
            }
        } else {
            T = exprType;
        }
    }
    return new Result<TypeRef>(T);
}

Example 7 with TClass

use of org.eclipse.n4js.ts.types.TClass in project n4js by eclipse.

the class MemberRedefinitionUtils method findThisContextForConstructor.

/**
 * Returns the context type to be used as this binding (see
 * {@link N4JSTypeSystem#createRuleEnvironmentForContext(TypeRef, TypeRef, Resource) here} and
 * {@link RuleEnvironmentExtensions#addThisType(RuleEnvironment, TypeRef)} here) for checking constructor
 * compatibility.
 *
 * For example, given the following code
 *
 * <pre>
 * class C1 {
 *     constructor(@Spec spec: ~i~this) {}
 * }
 *
 * class C2 extends C1 {
 *     public field2;
 * }
 *
 * &#64;CovariantConstructor
 * class C3 extends C2 {
 *     public field3;
 * }
 *
 * class C4 extends C3 {
 *     // XPECT noerrors -->
 *     constructor(@Spec spec: ~i~this) { super(spec); }
 * }
 * </pre>
 *
 * When checking constructor compatibility in C4, we have to use class C3 as the 'this' context on right-hand side,
 * not class C1, because the addition of fields <code>field2</code> and <code>field3</code> does not break the
 * contract of the &#64;CovariantConstructor annotation. Therefore, we cannot simply use the containing type of the
 * right-hand side constructor as 'this' context. In the above example, we would call this method with C4 as
 * <code>baseContext</code> and C1's constructor as <code>ctor</code> and it would return C3 as the 'this' context
 * to use.
 */
public static final Type findThisContextForConstructor(Type baseContext, TMethod ctor) {
    final Type ctorContainer = ctor.getContainingType();
    if (!(baseContext instanceof TClass) || !(ctorContainer instanceof TClass)) {
        return ctorContainer;
    }
    final TClass ctorContainerCasted = (TClass) ctorContainer;
    final TClass baseContextCasted = (TClass) baseContext;
    if (N4JSLanguageUtils.hasCovariantConstructor(ctorContainerCasted)) {
        return ctorContainerCasted;
    }
    final List<TClass> superClassesUpToCtorContainer = new ArrayList<>();
    for (TClass superClass : new ExtendedClassesIterable(baseContextCasted)) {
        if (superClass != ctorContainerCasted) {
            superClassesUpToCtorContainer.add(superClass);
        } else {
            break;
        }
    }
    for (int i = superClassesUpToCtorContainer.size() - 1; i >= 0; i--) {
        final TClass superClass = superClassesUpToCtorContainer.get(i);
        if (N4JSLanguageUtils.hasCovariantConstructor(superClass)) {
            return superClass;
        }
    }
    return baseContext;
}

Example 8 with TClass

use of org.eclipse.n4js.ts.types.TClass in project n4js by eclipse.

the class SpecModuleFile method addTypeElement.

private void addTypeElement(Type type, SpecIdentifiableElementSection specIE) {
    types.add(type);
    if (!typeElementsOfType.containsKey(type)) {
        SortedSet<SpecIdentifiableElementSection> containerElements = new TreeSet<>(memberComparator);
        typeElementsOfType.put(type, containerElements);
    }
    SortedSet<SpecIdentifiableElementSection> containerElements = typeElementsOfType.get(type);
    boolean addToList = !containerElements.contains(specIE);
    if (specIE.idElement.eContainer() instanceof TClass) {
        TClass tClass = (TClass) specIE.idElement.eContainer();
        addToList |= tClass.isStaticPolyfill();
    }
    if (addToList) {
        containerElements.add(specIE);
        allSections.add(specIE);
    }
}

Example 9 with TClass

use of org.eclipse.n4js.ts.types.TClass in project n4js by eclipse.

the class ConcreteMembersOrderedForTranspiler method create.

/**
 * Returns a tuple of collections used by transpiler to generate interface or class members.
 */
public static ConcreteMembersOrderedForTranspiler create(ContainerTypesHelper containerTypesHelper, TClassifier type, Script context) {
    MemberCollector collector = containerTypesHelper.fromContext(context);
    List<TMember> concreteInheritedMembers = (type instanceof TClass) ? collector.inheritedMembers((TClass) type) : emptyList();
    List<TMember> ownedAndMixedInConcreteMembers = collector.computeOwnedAndMixedInConcreteMembers(type);
    List<AccessorTuple> concreteAccessorTuples = getConcreteFieldAccessors(ownedAndMixedInConcreteMembers, concreteInheritedMembers);
    MemberList<TField> fieldsOverridingAccessors = getFieldsOverridingAccessor(ownedAndMixedInConcreteMembers, concreteInheritedMembers);
    // compute the list of mixed in fields, which do not override any Accessor (handled separately)
    MemberList<TField> fieldsPurelyMixedInNotOverridingAccessor = new MemberList<>();
    fieldsPurelyMixedInNotOverridingAccessor.addAll(ownedAndMixedInConcreteMembers.stream().filter(it -> it instanceof TField && // must stem from different type
    it.getContainingType() != type).map(it -> (TField) it).filter(// remove the ones overriding get/set
    it -> !fieldsOverridingAccessors.contains(it)).collect(Collectors.toList()));
    return new ConcreteMembersOrderedForTranspiler(concreteInheritedMembers, ownedAndMixedInConcreteMembers, concreteAccessorTuples, fieldsOverridingAccessors, fieldsPurelyMixedInNotOverridingAccessor);
}

Example 10 with TClass

use of org.eclipse.n4js.ts.types.TClass in project n4js by eclipse.

the class ScriptApiTracker method computeMissingApiMethods.

/**
 * @param type
 *            type to search for APIs.
 * @param context
 *            context holding the comparison-adapter
 * @return List of {@link VirtualApiTMethod}
 */
public List<TMethod> computeMissingApiMethods(TClass type, EObject context) {
    Optional<ProjectComparisonAdapter> optAdapt = firstProjectComparisonAdapter(context.eResource());
    if (optAdapt.isPresent()) {
        ProjectComparisonEntry compareEntry = optAdapt.get().getEntryFor(EcoreUtil2.getContainerOfType(type, TModule.class));
        ProjectComparisonEntry typeCompare = compareEntry.getChildForElementImpl(type);
        if (typeCompare != null) {
            return typeCompare.allChildren().filter(pce -> pce.getElementAPI() instanceof TMethod).filter(pce -> pce.getElementImpl()[0] == null).map(pce -> {
                TMethod apiMethod = (TMethod) pce.getElementAPI();
                TMethod copy = TypeUtils.copyPartial(apiMethod, TypesPackage.Literals.SYNTAX_RELATED_TELEMENT__AST_ELEMENT);
                TMethod ret = new VirtualApiTMethod(apiMethod.getName(), copy);
                return ret;
            }).collect(Collectors.toList());
        }
    }
    return emptyList();
}