TypeScript/tests/baselines/reference/stringLiteralTypeIsSubtypeOfString.js

//// [stringLiteralTypeIsSubtypeOfString.ts]
// string literal types are subtypes of string, any

// ok
function f1(x: 'a');
function f1(x: string);
function f1(x: string) { }

// ok
function f2(x: 'a');
function f2(x: any);
function f2(x: any) { }

// errors
function f3(x: 'a');
function f3(x: Object);
function f3(x: any) { }

function f4(x: 'a');
function f4(x: {});
function f4(x: any) { }

function f5(x: 'a');
function f5(x: number);
function f5(x: any) { }

function f6(x: 'a');
function f6(x: boolean);
function f6(x: any) { }

function f7(x: 'a');
function f7(x: Date);
function f7(x: any) { }

function f8(x: 'a');
function f8(x: RegExp);
function f8(x: any) { }

function f9(x: 'a');
function f9(x: () => {});
function f9(x: any) { }

class C implements String {
    toString(): string { return null; }
    charAt(pos: number): string { return null; }
    charCodeAt(index: number): number { return null; }
    concat(...strings: string[]): string { return null; }
    indexOf(searchString: string, position?: number): number { return null; }
    lastIndexOf(searchString: string, position?: number): number { return null; }
    localeCompare(that: string): number { return null; }
    match(regexp: any): string[] { return null; }
    replace(searchValue: any, replaceValue: any): string { return null; }
    search(regexp: any): number { return null; }
    slice(start?: number, end?: number): string { return null; }
    split(separator: any, limit?: number): string[] { return null; }
    substring(start: number, end?: number): string { return null; }
    toLowerCase(): string { return null; }
    toLocaleLowerCase(): string { return null; }
    toUpperCase(): string { return null; }
    toLocaleUpperCase(): string { return null; }
    trim(): string { return null; }
    length: number;
    substr(from: number, length?: number): string { return null; }
    [index: number]: string;
}
 
// BUG 831846
function f10(x: 'a');
function f10(x: C);
function f10(x: any) { }

interface I extends String {
    foo: string;
}

// BUG 831846
function f11(x: 'a');
function f11(x: I);
function f11(x: any) { }

function f12<T>(x: 'a');
function f12<T>(x: T);
function f12<T>(x: any) { }

function f13<T extends String>(x: 'a');
function f13<T extends String>(x: T);
function f13<T extends String>(x: any) { }

enum E { A }
function f14(x: 'a');
function f14(x: E);
function f14(x: any) { }

function f15<T, U extends T>(x: 'a');
function f15<T, U extends T>(x: U);
function f15<T, U extends T>(x: any) { }

function f16<T extends String, U extends T>(x: 'a');
function f16<T extends String, U extends T>(x: U);
function f16<T extends String, U extends T>(x: any) { }

//// [stringLiteralTypeIsSubtypeOfString.js]
function f1(x) {
}
function f2(x) {
}
function f3(x) {
}
function f4(x) {
}
function f5(x) {
}
function f6(x) {
}
function f7(x) {
}
function f8(x) {
}
function f9(x) {
}
var C = (function () {
    function C() {
    }
    C.prototype.toString = function () {
        return null;
    };
    C.prototype.charAt = function (pos) {
        return null;
    };
    C.prototype.charCodeAt = function (index) {
        return null;
    };
    C.prototype.concat = function () {
        var strings = [];
        for (var _i = 0; _i < arguments.length; _i++) {
            strings[_i - 0] = arguments[_i];
        }
        return null;
    };
    C.prototype.indexOf = function (searchString, position) {
        return null;
    };
    C.prototype.lastIndexOf = function (searchString, position) {
        return null;
    };
    C.prototype.localeCompare = function (that) {
        return null;
    };
    C.prototype.match = function (regexp) {
        return null;
    };
    C.prototype.replace = function (searchValue, replaceValue) {
        return null;
    };
    C.prototype.search = function (regexp) {
        return null;
    };
    C.prototype.slice = function (start, end) {
        return null;
    };
    C.prototype.split = function (separator, limit) {
        return null;
    };
    C.prototype.substring = function (start, end) {
        return null;
    };
    C.prototype.toLowerCase = function () {
        return null;
    };
    C.prototype.toLocaleLowerCase = function () {
        return null;
    };
    C.prototype.toUpperCase = function () {
        return null;
    };
    C.prototype.toLocaleUpperCase = function () {
        return null;
    };
    C.prototype.trim = function () {
        return null;
    };
    C.prototype.substr = function (from, length) {
        return null;
    };
    return C;
})();
function f10(x) {
}
function f11(x) {
}
function f12(x) {
}
function f13(x) {
}
var E;
(function (E) {
    E[E["A"] = 0] = "A";
})(E || (E = {}));
function f14(x) {
}
function f15(x) {
}
function f16(x) {
}