@polymer/gen-typescript-declarations/lib/closure-types.js

"use strict";
/**
 * @license
 * Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
 * This code may only be used under the BSD style license found at
 * http://polymer.github.io/LICENSE.txt The complete set of authors may be found
 * at http://polymer.github.io/AUTHORS.txt The complete set of contributors may
 * be found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by
 * Google as part of the polymer project is also subject to an additional IP
 * rights grant found at http://polymer.github.io/PATENTS.txt
 */
Object.defineProperty(exports, "__esModule", { value: true });
const ts = require("./ts-ast");
const { parseType, parseParamType } = require('doctrine/lib/typed.js');
/**
 * Convert from a type annotation in Closure syntax to a TypeScript type
 * expression AST (e.g `Array` => `Array<any>|null`).
 */
function closureTypeToTypeScript(closureType, templateTypes = []) {
    if (!closureType) {
        return ts.anyType;
    }
    let ast;
    try {
        ast = parseType(closureType);
    }
    catch (_a) {
        return ts.anyType;
    }
    return convert(ast, templateTypes);
}
exports.closureTypeToTypeScript = closureTypeToTypeScript;
/**
 * Convert from a parameter type annotation in Closure syntax to a TypeScript
 * type expression AST
 * (e.g `Array=` => `{type: 'Array<any>|null', optional: true}`).
 */
function closureParamToTypeScript(closureType, templateTypes = []) {
    if (!closureType) {
        return { type: ts.anyType, optional: false, rest: false };
    }
    let ast;
    try {
        ast = parseParamType(closureType);
    }
    catch (_a) {
        return {
            type: ts.anyType,
            // It's important we try to get optional right even if we can't parse
            // the annotation, because non-optional arguments can't follow optional
            // ones.
            optional: closureType.endsWith('='),
            rest: false,
        };
    }
    // Optional and Rest types are always the top-level node.
    switch (ast.type) {
        case 'OptionalType':
            return {
                type: convert(ast.expression, templateTypes),
                optional: true,
                rest: false,
            };
        case 'RestType':
            return {
                // The Closure type annotation for a rest parameter looks like
                // `...foo`, where `foo` is implicitly an array. The TypeScript
                // equivalent is explicitly an array, so we wrap it in one here.
                type: new ts.ArrayType(convert(ast.expression, templateTypes)),
                optional: false,
                rest: true,
            };
        default:
            return {
                type: convert(ast, templateTypes),
                optional: false,
                rest: false,
            };
    }
}
exports.closureParamToTypeScript = closureParamToTypeScript;
/**
 * Format the given Closure type expression AST node as a TypeScript type
 * annotation string.
 */
function convert(node, templateTypes) {
    let nullable;
    if (isNullable(node)) {
        nullable = true;
        node = node.expression;
    }
    else if (isNonNullable(node)) {
        nullable = false;
        node = node.expression;
    }
    else if (isName(node) && templateTypes.includes(node.name)) {
        // A template type "T" looks naively like a regular name type to doctrine
        // (e.g. a class called "T"), which would be nullable by default. However,
        // template types are not nullable by default.
        nullable = false;
    }
    else {
        nullable = nullableByDefault(node);
    }
    let t;
    if (isParameterizedArray(node)) {
        t = convertArray(node, templateTypes);
    }
    else if (isUnion(node)) {
        t = convertUnion(node, templateTypes);
    }
    else if (isFunction(node)) {
        t = convertFunction(node, templateTypes);
    }
    else if (isBareArray(node)) {
        t = new ts.ArrayType(ts.anyType);
    }
    else if (isRecordType(node)) {
        t = convertRecord(node, templateTypes);
    }
    else if (isAllLiteral(node)) {
        t = ts.anyType;
    }
    else if (isNullableLiteral(node)) {
        t = ts.anyType;
    }
    else if (isNullLiteral(node)) {
        t = ts.nullType;
    }
    else if (isUndefinedLiteral(node)) {
        t = ts.undefinedType;
    }
    else if (isVoidLiteral(node)) {
        t = new ts.NameType('void');
    }
    else if (isName(node)) {
        if (node.name === 'Object') {
            // Closure's `Object` type excludes primitives, so it is closest to
            // TypeScript's `object`. (Technically this should be `object|Symbol`,
            // but we will concede that technicality.)
            t = new ts.NameType('object');
        }
        else {
            t = new ts.NameType(node.name);
        }
    }
    else {
        console.error('Unknown syntax.');
        return ts.anyType;
    }
    if (nullable) {
        t = new ts.UnionType([t, ts.nullType]);
    }
    return t;
}
/**
 * Return whether the given AST node is an expression that is nullable by
 * default in the Closure type system.
 */
function nullableByDefault(node) {
    if (isName(node)) {
        switch (node.name) {
            case 'string':
            case 'number':
            case 'boolean':
            case 'void':
                return false;
        }
        return true;
    }
    return isParameterizedArray(node);
}
function convertArray(node, templateTypes) {
    const applications = node.applications;
    return new ts.ArrayType(applications.length === 1 ? convert(applications[0], templateTypes) :
        ts.anyType);
}
function convertUnion(node, templateTypes) {
    return new ts.UnionType(node.elements.map((element) => convert(element, templateTypes)));
}
function convertFunction(node, templateTypes) {
    const params = node.params.map((param, idx) => new ts.ParamType(
    // TypeScript wants named parameters, but we don't have names.
    'p' + idx, convert(param, templateTypes)));
    if (node.new) {
        return new ts.ConstructorType(params, 
        // It doesn't make sense for a constructor to return something other
        // than a named type. Also, in this context the name type is not
        // nullable by default, so it's simpler to just directly convert here.
        isName(node.this) ? new ts.NameType(node.this.name) : ts.anyType);
    }
    else {
        return new ts.FunctionType(params, 
        // Cast because type is wrong: `FunctionType.result` is not an array.
        node.result ? convert(node.result, templateTypes) : ts.anyType);
    }
}
function convertRecord(node, templateTypes) {
    const fields = [];
    for (const field of node.fields) {
        if (field.type !== 'FieldType') {
            return ts.anyType;
        }
        let fieldType = field.value ? convert(field.value, templateTypes) : ts.anyType;
        // In Closure you can't declare a record field optional, instead you
        // declare `foo: bar|undefined`. In TypeScript we can represent this as
        // `foo?: bar`. This also matches the semantics better, since Closure would
        // allow the field to be omitted when it is `|undefined`, but TypeScript
        // would require it to be explicitly set to `undefined`.
        let optional = false;
        if (fieldType.kind === 'union') {
            fieldType.members = fieldType.members.filter((member) => {
                if (member.kind === 'name' && member.name === 'undefined') {
                    optional = true;
                    return false;
                }
                return true;
            });
            // No need for a union if we collapsed it to one member.
            fieldType.simplify();
        }
        fields.push(new ts.ParamType(field.key, fieldType, optional));
    }
    return new ts.RecordType(fields);
}
function isParameterizedArray(node) {
    return node.type === 'TypeApplication' &&
        node.expression.type === 'NameExpression' &&
        node.expression.name === 'Array';
}
function isBareArray(node) {
    return node.type === 'NameExpression' && node.name === 'Array';
}
function isUnion(node) {
    return node.type === 'UnionType';
}
function isFunction(node) {
    return node.type === 'FunctionType';
}
function isRecordType(node) {
    return node.type === 'RecordType';
}
function isNullable(node) {
    return node.type === 'NullableType';
}
function isNonNullable(node) {
    return node.type === 'NonNullableType';
}
function isAllLiteral(node) {
    return node.type === 'AllLiteral';
}
function isNullLiteral(node) {
    return node.type === 'NullLiteral';
}
function isNullableLiteral(node) {
    return node.type === 'NullableLiteral';
}
function isUndefinedLiteral(node) {
    return node.type === 'UndefinedLiteral';
}
function isVoidLiteral(node) {
    return node.type === 'VoidLiteral';
}
function isName(node) {
    return node.type === 'NameExpression';
}
//# sourceMappingURL=closure-types.js.map