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

Example 76 with Type

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

the class InternalTypeSystem method applyRuleTypePropertyAccessExpression.

protected Result<TypeRef> applyRuleTypePropertyAccessExpression(final RuleEnvironment G, final RuleApplicationTrace _trace_, final ParameterizedPropertyAccessExpression expr) throws RuleFailedException {
    // output parameter
    TypeRef T = null;
    /* { T = env(G, GUARD_TYPE_PROPERTY_ACCESS_EXPRESSION -> expr, TypeRef) } or { val G2 = G.wrap G2.add(GUARD_TYPE_PROPERTY_ACCESS_EXPRESSION -> expr, G2.anyTypeRef) G2 |- expr.target : var TypeRef receiverTypeRef typeSystemHelper.addSubstitutions(G2,receiverTypeRef) G2.addThisType(receiverTypeRef) if (! (receiverTypeRef instanceof UnknownTypeRef) && (expr.target instanceof SuperLiteral || expr.target instanceof ThisLiteral) ) { var containingClass = EcoreUtil2.getContainerOfType(expr,N4ClassDeclaration)?.definedType; if (containingClass instanceof TClass) { if (containingClass.isStaticPolyfill) { containingClass = containingClass.superClassRef?.declaredType } if (containingClass instanceof TClass) { if (containingClass?.superClassRef!==null) { typeSystemHelper.addSubstitutions(G2, containingClass.superClassRef) } } } } val prop = expr.property; var TypeRef propTypeRef; if(prop instanceof TMethod && (prop as TMethod).isConstructor) { val TypeArgument ctorTypeArg = switch(receiverTypeRef) { TypeTypeRef: G.functionTypeRef ParameterizedTypeRef, BoundThisTypeRef: { val declType = if(receiverTypeRef instanceof BoundThisTypeRef) { receiverTypeRef.actualThisTypeRef?.declaredType } else { receiverTypeRef.declaredType }; val finalCtorSig = if(declType instanceof TClassifier) N4JSLanguageUtils.hasCovariantConstructor(declType); if(finalCtorSig) { declType.ref } else if(declType!==null) { TypeUtils.createWildcardExtends(declType.ref) } else { null } } }; propTypeRef = if(ctorTypeArg!==null) { TypeUtils.createTypeTypeRef(ctorTypeArg, true) } else { TypeRefsFactory.eINSTANCE.createUnknownTypeRef }; } else if(receiverTypeRef.dynamic && prop!==null && prop.eIsProxy) { propTypeRef = G.anyTypeRefDynamic; } else { G2.wrap |- prop : propTypeRef if(expr.parameterized) { typeSystemHelper.addSubstitutions(G2,expr); } } G2 |- propTypeRef ~> T T = versionResolver.resolveVersion(T, receiverTypeRef); if (expr.target instanceof SuperLiteral && T instanceof FunctionTypeExprOrRef ) { val F = T as FunctionTypeExprOrRef; if ((T as FunctionTypeExprOrRef).returnTypeRef instanceof BoundThisTypeRef) { var TypeRef rawT; G |~ expr ~> rawT; val thisTypeRef = TypeUtils.enforceNominalTyping(rawT); if (T instanceof FunctionTypeExpression && T.eContainer===null) { val fte = T as FunctionTypeExpression fte.returnTypeRef = TypeUtils.copyIfContained(thisTypeRef); } else { T = TypeUtils.createFunctionTypeExpression(null, F.typeVars, F.fpars, thisTypeRef); } } } } */
    {
        RuleFailedException previousFailure = null;
        try {
            Pair<String, ParameterizedPropertyAccessExpression> _mappedTo = Pair.<String, ParameterizedPropertyAccessExpression>of(RuleEnvironmentExtensions.GUARD_TYPE_PROPERTY_ACCESS_EXPRESSION, expr);
            T = this.<TypeRef>env(G, _mappedTo, TypeRef.class);
        } catch (Exception e) {
            previousFailure = extractRuleFailedException(e);
            final RuleEnvironment G2 = RuleEnvironmentExtensions.wrap(G);
            Pair<String, ParameterizedPropertyAccessExpression> _mappedTo_1 = Pair.<String, ParameterizedPropertyAccessExpression>of(RuleEnvironmentExtensions.GUARD_TYPE_PROPERTY_ACCESS_EXPRESSION, expr);
            boolean _add = G2.add(_mappedTo_1, RuleEnvironmentExtensions.anyTypeRef(G2));
            /* G2.add(GUARD_TYPE_PROPERTY_ACCESS_EXPRESSION -> expr, G2.anyTypeRef) */
            if (!_add) {
                sneakyThrowRuleFailedException("G2.add(GUARD_TYPE_PROPERTY_ACCESS_EXPRESSION -> expr, G2.anyTypeRef)");
            }
            /* G2 |- expr.target : var TypeRef receiverTypeRef */
            Expression _target = expr.getTarget();
            TypeRef receiverTypeRef = null;
            Result<TypeRef> result = typeInternal(G2, _trace_, _target);
            checkAssignableTo(result.getFirst(), TypeRef.class);
            receiverTypeRef = (TypeRef) result.getFirst();
            this.typeSystemHelper.addSubstitutions(G2, receiverTypeRef);
            RuleEnvironmentExtensions.addThisType(G2, receiverTypeRef);
            if (((!(receiverTypeRef instanceof UnknownTypeRef)) && ((expr.getTarget() instanceof SuperLiteral) || (expr.getTarget() instanceof ThisLiteral)))) {
                N4ClassDeclaration _containerOfType = EcoreUtil2.<N4ClassDeclaration>getContainerOfType(expr, N4ClassDeclaration.class);
                Type _definedType = null;
                if (_containerOfType != null) {
                    _definedType = _containerOfType.getDefinedType();
                }
                Type containingClass = _definedType;
                if ((containingClass instanceof TClass)) {
                    boolean _isStaticPolyfill = ((TClass) containingClass).isStaticPolyfill();
                    if (_isStaticPolyfill) {
                        ParameterizedTypeRef _superClassRef = ((TClass) containingClass).getSuperClassRef();
                        Type _declaredType = null;
                        if (_superClassRef != null) {
                            _declaredType = _superClassRef.getDeclaredType();
                        }
                        containingClass = _declaredType;
                    }
                    if ((containingClass instanceof TClass)) {
                        ParameterizedTypeRef _superClassRef_1 = null;
                        if (((TClass) containingClass) != null) {
                            _superClassRef_1 = ((TClass) containingClass).getSuperClassRef();
                        }
                        boolean _tripleNotEquals = (_superClassRef_1 != null);
                        if (_tripleNotEquals) {
                            this.typeSystemHelper.addSubstitutions(G2, ((TClass) containingClass).getSuperClassRef());
                        }
                    }
                }
            }
            final IdentifiableElement prop = expr.getProperty();
            TypeRef propTypeRef = null;
            if (((prop instanceof TMethod) && ((TMethod) prop).isConstructor())) {
                TypeArgument _switchResult = null;
                boolean _matched = false;
                if (receiverTypeRef instanceof TypeTypeRef) {
                    _matched = true;
                    _switchResult = RuleEnvironmentExtensions.functionTypeRef(G);
                }
                if (!_matched) {
                    if (receiverTypeRef instanceof ParameterizedTypeRef) {
                        _matched = true;
                    }
                    if (!_matched) {
                        if (receiverTypeRef instanceof BoundThisTypeRef) {
                            _matched = true;
                        }
                    }
                    if (_matched) {
                        TypeArgument _xblockexpression = null;
                        {
                            Type _xifexpression = null;
                            if ((receiverTypeRef instanceof BoundThisTypeRef)) {
                                ParameterizedTypeRef _actualThisTypeRef = ((BoundThisTypeRef) receiverTypeRef).getActualThisTypeRef();
                                Type _declaredType_1 = null;
                                if (_actualThisTypeRef != null) {
                                    _declaredType_1 = _actualThisTypeRef.getDeclaredType();
                                }
                                _xifexpression = _declaredType_1;
                            } else {
                                _xifexpression = ((BaseTypeRef) receiverTypeRef).getDeclaredType();
                            }
                            final Type declType = _xifexpression;
                            boolean _xifexpression_1 = false;
                            if ((declType instanceof TClassifier)) {
                                _xifexpression_1 = N4JSLanguageUtils.hasCovariantConstructor(((TClassifier) declType));
                            }
                            final boolean finalCtorSig = _xifexpression_1;
                            TypeArgument _xifexpression_2 = null;
                            if (finalCtorSig) {
                                _xifexpression_2 = TypeExtensions.ref(declType);
                            } else {
                                Wildcard _xifexpression_3 = null;
                                if ((declType != null)) {
                                    _xifexpression_3 = TypeUtils.createWildcardExtends(TypeExtensions.ref(declType));
                                } else {
                                    _xifexpression_3 = null;
                                }
                                _xifexpression_2 = _xifexpression_3;
                            }
                            _xblockexpression = (_xifexpression_2);
                        }
                        _switchResult = _xblockexpression;
                    }
                }
                final TypeArgument ctorTypeArg = _switchResult;
                TypeRef _xifexpression = null;
                if ((ctorTypeArg != null)) {
                    _xifexpression = TypeUtils.createTypeTypeRef(ctorTypeArg, true);
                } else {
                    _xifexpression = TypeRefsFactory.eINSTANCE.createUnknownTypeRef();
                }
                propTypeRef = _xifexpression;
            } else {
                if (((receiverTypeRef.isDynamic() && (prop != null)) && prop.eIsProxy())) {
                    propTypeRef = RuleEnvironmentExtensions.anyTypeRefDynamic(G);
                } else {
                    /* G2.wrap |- prop : propTypeRef */
                    RuleEnvironment _wrap = RuleEnvironmentExtensions.wrap(G2);
                    Result<TypeRef> result_1 = typeInternal(_wrap, _trace_, prop);
                    checkAssignableTo(result_1.getFirst(), TypeRef.class);
                    propTypeRef = (TypeRef) result_1.getFirst();
                    boolean _isParameterized = expr.isParameterized();
                    if (_isParameterized) {
                        this.typeSystemHelper.addSubstitutions(G2, expr);
                    }
                }
            }
            /* G2 |- propTypeRef ~> T */
            Result<TypeArgument> result_2 = substTypeVariablesInternal(G2, _trace_, propTypeRef);
            checkAssignableTo(result_2.getFirst(), TypeRef.class);
            T = (TypeRef) result_2.getFirst();
            T = this.versionResolver.<TypeRef, TypeRef>resolveVersion(T, receiverTypeRef);
            if (((expr.getTarget() instanceof SuperLiteral) && (T instanceof FunctionTypeExprOrRef))) {
                final FunctionTypeExprOrRef F = ((FunctionTypeExprOrRef) T);
                TypeRef _returnTypeRef = ((FunctionTypeExprOrRef) T).getReturnTypeRef();
                if ((_returnTypeRef instanceof BoundThisTypeRef)) {
                    TypeRef rawT = null;
                    /* G |~ expr ~> rawT */
                    Result<TypeRef> result_3 = thisTypeRefInternal(G, _trace_, expr);
                    checkAssignableTo(result_3.getFirst(), TypeRef.class);
                    rawT = (TypeRef) result_3.getFirst();
                    final TypeRef thisTypeRef = TypeUtils.enforceNominalTyping(rawT);
                    if (((T instanceof FunctionTypeExpression) && (T.eContainer() == null))) {
                        final FunctionTypeExpression fte = ((FunctionTypeExpression) T);
                        fte.setReturnTypeRef(TypeUtils.<TypeRef>copyIfContained(thisTypeRef));
                    } else {
                        T = TypeUtils.createFunctionTypeExpression(null, F.getTypeVars(), F.getFpars(), thisTypeRef);
                    }
                }
            }
        }
    }
    return new Result<TypeRef>(T);
}

Example 77 with Type

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

the class N4JSDReader method readScripts.

/**
 * Reads all N4JSD files in project and scans for types. No further information is added yet. Reads all types into a
 * map with fully qualified type name (inclusive module spec) as key, the type info only contains the types, no
 * other information yet.
 *
 * @param specInfoByName
 *            map of fqn of types or reqid keys to their corresponding spec info.
 * @throws InterruptedException
 *             thrown when user cancels the operation
 */
private void readScripts(Multimap<String, SpecInfo> specInfoByName, IN4JSProject project, ResourceSet resSet, SubMonitorMsg monitor) throws InterruptedException {
    ImmutableList<? extends IN4JSSourceContainer> srcCont = project.getSourceContainers();
    List<IN4JSSourceContainer> srcContFilter = new LinkedList<>();
    int count = 0;
    for (IN4JSSourceContainer container : srcCont) {
        if (container.isSource() || container.isTest()) {
            count += Iterables.size(container);
            srcContFilter.add(container);
        }
    }
    SubMonitorMsg sub = monitor.convert(count);
    for (IN4JSSourceContainer container : srcContFilter) {
        for (URI uri : container) {
            String ext = uri.fileExtension();
            if ("n4js".equals(ext) || "n4jsd".equals(ext)) {
                try {
                    Resource resource = resSet.getResource(uri, true);
                    if (resource != null) {
                        Script script = (Script) (resource.getContents().isEmpty() ? null : resource.getContents().get(0));
                        if (script == null) {
                            // throw new IllegalStateException("Error parsing " + uri);
                            continue;
                        }
                        N4JSResource.postProcess(resource);
                        for (Type type : getRealTopLevelTypes(script)) {
                            createTypeSpecInfo(type, specInfoByName);
                        }
                        for (TVariable tvar : script.getModule().getVariables()) {
                            createTVarSpecInfo(tvar, specInfoByName);
                        }
                    }
                } catch (Exception ex) {
                    ex.printStackTrace();
                    String msg = "Error processing " + uri + ": " + ex.getMessage();
                    throw new IllegalArgumentException(msg, ex);
                }
            }
            sub.worked(1);
            sub.checkCanceled();
        }
    }
}

Example 78 with Type

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

the class N4JSDReader method linkTests.

/**
 * Links the tests to the testees and may create new specInfos for requirement ID related tests.
 *
 * @throws InterruptedException
 *             thrown when user cancels the operation
 */
private void linkTests(Multimap<String, SpecInfo> specInfoByName, IN4JSProject project, ResourceSet resSet, SubMonitorMsg monitor) throws InterruptedException {
    List<Type> testTypes = getTestTypes(project, resSet, monitor);
    for (Type testType : testTypes) {
        try {
            if (testType instanceof TClassifier) {
                TClassifier ctype = (TClassifier) testType;
                processClassifier(specInfoByName, testType, ctype);
            }
        } catch (Exception ex) {
            ex.printStackTrace();
            String msg = "Error processing " + testType.eResource().getURI().toString() + ": " + ex.getMessage();
            throw new IllegalArgumentException(msg);
        }
    }
}

Example 79 with Type

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

the class N4JSDReader method getTestTypes.

private List<Type> getTestTypes(IN4JSProject project, ResourceSet resSet, SubMonitorMsg monitor) throws InterruptedException {
    List<Type> testTypes = new ArrayList<>();
    ImmutableList<? extends IN4JSSourceContainer> srcCont = project.getSourceContainers();
    // count container
    int count = 0;
    for (IN4JSSourceContainer container : srcCont) {
        if (container.isTest()) {
            count += Iterables.size(container);
        }
    }
    SubMonitorMsg sub = monitor.convert(count);
    // scan for types
    for (IN4JSSourceContainer container : srcCont) {
        if (container.isTest()) {
            for (URI uri : container) {
                String ext = uri.fileExtension();
                if ("n4js".equals(ext)) {
                    Resource resource = resSet.getResource(uri, true);
                    if (resource != null) {
                        Script script = (Script) (resource.getContents().isEmpty() ? null : resource.getContents().get(0));
                        if (script == null) {
                            throw new IllegalStateException("Error parsing " + uri);
                        }
                        N4JSResource.postProcess(resource);
                        for (Type type : getRealTopLevelTypes(script)) {
                            testTypes.add(type);
                        }
                    }
                }
                sub.worked(1);
                sub.checkCanceled();
            }
        }
    }
    return testTypes;
}

Example 80 with Type

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

the class N4JSDReader method createTypeSpecInfo.

private void createTypeSpecInfo(Type type, Multimap<String, SpecInfo> specInfoByName) {
    SpecInfo typeInfo = new SpecInfo(type);
    String regionName = KeyUtils.getSpecKeyWithoutProjectFolder(rrph, type);
    specInfoByName.put(regionName, typeInfo);
    Collection<SpecInfo> identicalSpecInfo = specInfoByName.get(regionName);
    if (identicalSpecInfo.size() > 1) {
        SpecInfo polyfillAware = null;
        List<SpecInfo> polyfilling = new LinkedList<>();
        for (SpecInfo si : identicalSpecInfo) {
            Type moduleType = si.specElementRef.getElementAsType();
            if (moduleType != null) {
                TModule typeModule = moduleType.getContainingModule();
                if (typeModule.isStaticPolyfillModule()) {
                    polyfilling.add(si);
                } else if (typeModule.isStaticPolyfillAware()) {
                    polyfillAware = si;
                }
            }
        }
        if (polyfillAware != null) {
            Type polyfillAwareType = polyfillAware.specElementRef.getElementAsType();
            for (SpecInfo si : polyfilling) {
                si.specElementRef.polyfillAware = polyfillAwareType;
            }
        }
    }
}