file_path stringlengths 3 280 | file_language stringclasses 66
values | content stringlengths 1 1.04M | repo_name stringlengths 5 92 | repo_stars int64 0 154k | repo_description stringlengths 0 402 | repo_primary_language stringclasses 108
values | developer_username stringlengths 1 25 | developer_name stringlengths 0 30 | developer_company stringlengths 0 82 |
|---|---|---|---|---|---|---|---|---|---|
crates/swc_ecma_parser/tests/tsc/asiPreventsParsingAsTypeAlias02.ts | TypeScript |
var type;
var string;
var Foo;
namespace container {
type
Foo = string;
} | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/assertionTypePredicates2.ts | TypeScript | // @allowJs: true
// @checkJs: true
// @outDir: ./out
// @filename: assertionTypePredicates2.js
/**
* @typedef {{ x: number }} A
*/
/**
* @typedef { A & { y: number } } B
*/
/**
* @param {A} a
* @returns { asserts a is B }
*/
const foo = (a) => {
if (/** @type { B } */ (a).y !== 0) throw TypeError();
return undefined;
};
export const main = () => {
/** @type { A } */
const a = { x: 1 };
foo(a);
};
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/assertionsAndNonReturningFunctions.ts | TypeScript | // @allowJs: true
// @checkJs: true
// @noEmit: true
// @allowUnreachableCode: false
// @filename: assertionsAndNonReturningFunctions.js
/** @typedef {(check: boolean) => asserts check} AssertFunc */
/** @type {AssertFunc} */
const assert = check => {
if (!check) throw new Error();
}
/** @type {(x: unknown) => asserts x is string } */
function assertIsString(x) {
if (!(typeof x === "string")) throw new Error();
}
/**
* @param {boolean} check
* @returns {asserts check}
*/
function assert2(check) {
if (!check) throw new Error();
}
/**
* @returns {never}
*/
function fail() {
throw new Error();
}
/**
* @param {*} x
*/
function f1(x) {
if (!!true) {
assert(typeof x === "string");
x.length;
}
if (!!true) {
assert2(typeof x === "string");
x.length;
}
if (!!true) {
assertIsString(x);
x.length;
}
if (!!true) {
fail();
x; // Unreachable
}
}
/**
* @param {boolean} b
*/
function f2(b) {
switch (b) {
case true: return 1;
case false: return 0;
}
b; // Unreachable
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/assignAnyToEveryType.ts | TypeScript | // all of these are valid
var x: any;
var a: number = x;
var b: boolean = x;
var c: string = x;
var d: void = x;
var e = null;
e = x;
var f = undefined;
f = x;
enum E {
A
}
var g: E = x;
var g2 = E.A;
g2 = x;
class C {
foo: string;
}
var h: C = x;
interface I {
foo: string;
}
var i: I = x;
var j: { (): string } = x;
var j2: { <T>(x: T): string } = x;
module M {
export var foo = 1;
}
M = x;
function k<T>(a: T) {
a = x;
} | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/assignEveryTypeToAny.ts | TypeScript | // all of these are valid
var x: any;
x = 1;
var a = 2;
x = a;
x = true;
var b = true;
x = b;
x = "";
var c = "";
x = c;
var d: void;
x = d;
var e = undefined;
x = e;
var e2: typeof undefined;
x = e2;
enum E {
A
}
x = E.A;
var f = E.A;
x = f;
interface I {
foo: string;
}
var g: I;
x = g;
class C {
bar: string;
}
var h: C;
x = h;
var i: { (): string };
x = i;
x = { f() { return 1; } }
x = { f<T>(x: T) { return x; } }
function j<T>(a: T) {
x = a;
} | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/assignFromBooleanInterface.ts | TypeScript | var x = true;
var a: Boolean;
x = a;
a = x; | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/assignFromBooleanInterface2.ts | TypeScript | interface Boolean {
doStuff(): string;
}
interface NotBoolean {
doStuff(): string;
}
var x = true;
var a: Boolean;
var b: NotBoolean;
a = x;
a = b;
b = a;
b = x;
x = a; // expected error
x = b; // expected error
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/assignFromNumberInterface.ts | TypeScript | var x = 1;
var a: Number;
x = a;
a = x; | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/assignFromNumberInterface2.ts | TypeScript | interface Number {
doStuff(): string;
}
interface NotNumber {
toString(radix?: number): string;
toFixed(fractionDigits?: number): string;
toExponential(fractionDigits?: number): string;
toPrecision(precision?: number): string;
valueOf(): number;
doStuff(): string;
}
var x = 1;
var a: Number;
var b: NotNumber;
a = x;
a = b;
b = a;
b = x;
x = a; // expected error
x = b; // expected error
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/assignFromStringInterface.ts | TypeScript | var x = '';
var a: String;
x = a;
a = x; | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/assignFromStringInterface2.ts | TypeScript | interface String {
doStuff(): string;
}
interface NotString {
doStuff(): string;
toString(): string;
charAt(pos: number): string;
charCodeAt(index: number): number;
concat(...strings: string[]): string;
indexOf(searchString: string, position?: number): number;
lastIndexOf(searchString: string, position?: number): number;
localeCompare(that: string): number;
match(regexp: string): RegExpMatchArray;
match(regexp: RegExp): RegExpMatchArray;
replace(searchValue: string, replaceValue: string): string;
replace(searchValue: string, replaceValue: (substring: string, ...args: any[]) => string): string;
replace(searchValue: RegExp, replaceValue: string): string;
replace(searchValue: RegExp, replaceValue: (substring: string, ...args: any[]) => string): string;
search(regexp: string): number;
search(regexp: RegExp): number;
slice(start?: number, end?: number): string;
split(separator: string, limit?: number): string[];
split(separator: RegExp, limit?: number): string[];
substring(start: number, end?: number): string;
toLowerCase(): string;
toLocaleLowerCase(): string;
toUpperCase(): string;
toLocaleUpperCase(): string;
trim(): string;
length: number;
substr(from: number, length?: number): string;
valueOf(): string;
[index: number]: string;
}
var x = '';
var a: String;
var b: NotString;
a = x;
a = b;
b = a;
b = x;
x = a; // expected error
x = b; // expected error
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/assignObjectToNonPrimitive.ts | TypeScript | var x = {};
var y = {foo: "bar"};
var a: object;
a = x;
a = y;
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/assignParameterPropertyToPropertyDeclarationES2022.ts | TypeScript | // @useDefineForClassFields: true
// @target: es2022
class C {
qux = this.bar // should error
bar = this.foo // should error
quiz = this.bar // ok
quench = this.m1() // ok
quanch = this.m3() // should error
m1() {
this.foo // ok
}
m3 = function() { }
constructor(public foo: string) {}
quim = this.baz // should error
baz = this.foo; // should error
quid = this.baz // ok
m2() {
this.foo // ok
}
}
class D extends C {
quill = this.foo // ok
}
class E {
bar = () => this.foo1 + this.foo2; // both ok
foo1 = '';
constructor(public foo2: string) {}
}
class F {
Inner = class extends F {
p2 = this.p1
}
p1 = 0
}
class G {
Inner = class extends G {
p2 = this.p1
}
constructor(public p1: number) {}
}
class H {
constructor(public p1: C) {}
public p2 = () => {
return this.p1.foo;
}
public p3 = () => this.p1.foo;
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/assignParameterPropertyToPropertyDeclarationESNext.ts | TypeScript | // @useDefineForClassFields: true
// @target: esnext
class C {
qux = this.bar // should error
bar = this.foo // should error
quiz = this.bar // ok
quench = this.m1() // ok
quanch = this.m3() // should error
m1() {
this.foo // ok
}
m3 = function() { }
constructor(public foo: string) {}
quim = this.baz // should error
baz = this.foo; // should error
quid = this.baz // ok
m2() {
this.foo // ok
}
}
class D extends C {
quill = this.foo // ok
}
class E {
bar = () => this.foo1 + this.foo2; // both ok
foo1 = '';
constructor(public foo2: string) {}
}
class F {
Inner = class extends F {
p2 = this.p1
}
p1 = 0
}
class G {
Inner = class extends G {
p2 = this.p1
}
constructor(public p1: number) {}
}
class H {
constructor(public p1: C) {}
public p2 = () => {
return this.p1.foo;
}
public p3 = () => this.p1.foo;
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/assignmentCompatBetweenTupleAndArray.ts | TypeScript | var numStrTuple: [number, string];
var numNumTuple: [number, number];
var numEmptyObjTuple: [number, {}];
var emptyObjTuple: [{}];
var numArray: number[];
var emptyObjArray: {}[];
// no error
numArray = numNumTuple;
emptyObjArray = emptyObjTuple;
emptyObjArray = numStrTuple;
emptyObjArray = numNumTuple;
emptyObjArray = numEmptyObjTuple;
// error
numArray = numStrTuple;
emptyObjTuple = emptyObjArray;
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/assignmentCompatWithCallSignatures.ts | TypeScript | // void returning call signatures can be assigned a non-void returning call signature that otherwise matches
interface T {
(x: number): void;
}
var t: T;
var a: { (x: number): void };
t = a;
a = t;
interface S {
(x: number): string;
}
var s: S;
var a2: { (x: number): string };
t = s;
t = a2;
a = s;
a = a2;
t = <T>(x: T) => 1;
t = () => 1;
t = function (x: number) { return ''; }
a = <T>(x: T) => 1;
a = () => 1;
a = function (x: number) { return ''; }
interface S2 {
(x: string): void;
}
var s2: S2;
var a3: { (x: string): void };
// these are errors
t = s2;
t = a3;
t = (x: string) => 1;
t = function (x: string) { return ''; }
a = s2;
a = a3;
a = (x: string) => 1;
a = function (x: string) { return ''; }
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/assignmentCompatWithCallSignatures2.ts | TypeScript | // void returning call signatures can be assigned a non-void returning call signature that otherwise matches
interface T {
f(x: number): void;
}
var t: T;
var a: { f(x: number): void };
t = a;
a = t;
interface S {
f(x: number): string;
}
var s: S;
var a2: { f(x: number): string };
t = s;
t = a2;
a = s;
a = a2;
t = { f: () => 1 };
t = { f: <T>(x:T) => 1 };
t = { f: function f() { return 1 } };
t = { f(x: number) { return ''; } }
a = { f: () => 1 }
a = { f: <T>(x: T) => 1 };
a = { f: function (x: number) { return ''; } }
// errors
t = () => 1;
t = function (x: number) { return ''; }
a = () => 1;
a = function (x: number) { return ''; }
interface S2 {
f(x: string): void;
}
var s2: S2;
var a3: { f(x: string): void };
// these are errors
t = s2;
t = a3;
t = (x: string) => 1;
t = function (x: string) { return ''; }
a = s2;
a = a3;
a = (x: string) => 1;
a = function (x: string) { return ''; }
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/assignmentCompatWithCallSignatures3.ts | TypeScript | // these are all permitted with the current rules, since we do not do contextual signature instantiation
class Base { foo: string; }
class Derived extends Base { bar: string; }
class Derived2 extends Derived { baz: string; }
class OtherDerived extends Base { bing: string; }
var a: (x: number) => number[];
var a2: (x: number) => string[];
var a3: (x: number) => void;
var a4: (x: string, y: number) => string;
var a5: (x: (arg: string) => number) => string;
var a6: (x: (arg: Base) => Derived) => Base;
var a7: (x: (arg: Base) => Derived) => (r: Base) => Derived;
var a8: (x: (arg: Base) => Derived, y: (arg2: Base) => Derived) => (r: Base) => Derived;
var a9: (x: (arg: Base) => Derived, y: (arg2: Base) => Derived) => (r: Base) => Derived;
var a10: (...x: Derived[]) => Derived;
var a11: (x: { foo: string }, y: { foo: string; bar: string }) => Base;
var a12: (x: Array<Base>, y: Array<Derived2>) => Array<Derived>;
var a13: (x: Array<Base>, y: Array<Derived>) => Array<Derived>;
var a14: (x: { a: string; b: number }) => Object;
var a15: {
(x: number): number[];
(x: string): string[];
}
var a16: {
<T extends Derived>(x: T): number[];
<U extends Base>(x: U): number[];
}
var a17: {
(x: (a: number) => number): number[];
(x: (a: string) => string): string[];
};
var a18: {
(x: {
(a: number): number;
(a: string): string;
}): any[];
(x: {
(a: boolean): boolean;
(a: Date): Date;
}): any[];
}
var b: <T>(x: T) => T[];
a = b; // ok
b = a; // ok
var b2: <T>(x: T) => string[];
a2 = b2; // ok
b2 = a2; // ok
var b3: <T>(x: T) => T;
a3 = b3; // ok
b3 = a3; // ok
var b4: <T, U>(x: T, y: U) => T;
a4 = b4; // ok
b4 = a4; // ok
var b5: <T, U>(x: (arg: T) => U) => T;
a5 = b5; // ok
b5 = a5; // ok
var b6: <T extends Base, U extends Derived>(x: (arg: T) => U) => T;
a6 = b6; // ok
b6 = a6; // ok
var b7: <T extends Base, U extends Derived>(x: (arg: T) => U) => (r: T) => U;
a7 = b7; // ok
b7 = a7; // ok
var b8: <T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: T) => U) => (r: T) => U;
a8 = b8; // ok
b8 = a8; // ok
var b9: <T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: { foo: string; bing: number }) => U) => (r: T) => U;
a9 = b9; // ok
b9 = a9; // ok
var b10: <T extends Derived>(...x: T[]) => T;
a10 = b10; // ok
b10 = a10; // ok
var b11: <T extends Base>(x: T, y: T) => T;
a11 = b11; // ok
b11 = a11; // ok
var b12: <T extends Array<Base>>(x: Array<Base>, y: T) => Array<Derived>;
a12 = b12; // ok
b12 = a12; // ok
var b13: <T extends Array<Derived>>(x: Array<Base>, y: T) => T;
a13 = b13; // ok
b13 = a13; // ok
var b14: <T>(x: { a: T; b: T }) => T;
a14 = b14; // ok
b14 = a14; // ok
var b15: <T>(x: T) => T[];
a15 = b15; // ok
b15 = a15; // ok
var b16: <T extends Base>(x: T) => number[];
a16 = b16; // ok
b16 = a16; // ok
var b17: <T>(x: (a: T) => T) => T[]; // ok
a17 = b17; // ok
b17 = a17; // ok
var b18: <T>(x: (a: T) => T) => T[];
a18 = b18; // ok
b18 = a18; // ok
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/assignmentCompatWithCallSignatures4.ts | TypeScript | // These are mostly permitted with the current loose rules. All ok unless otherwise noted.
module Errors {
class Base { foo: string; }
class Derived extends Base { bar: string; }
class Derived2 extends Derived { baz: string; }
class OtherDerived extends Base { bing: string; }
module WithNonGenericSignaturesInBaseType {
// target type with non-generic call signatures
var a2: (x: number) => string[];
var a7: (x: (arg: Base) => Derived) => (r: Base) => Derived2;
var a8: (x: (arg: Base) => Derived, y: (arg2: Base) => Derived) => (r: Base) => Derived;
var a10: (...x: Base[]) => Base;
var a11: (x: { foo: string }, y: { foo: string; bar: string }) => Base;
var a12: (x: Array<Base>, y: Array<Derived2>) => Array<Derived>;
var a14: {
(x: number): number[];
(x: string): string[];
};
var a15: (x: { a: string; b: number }) => number;
var a16: {
(x: {
(a: number): number;
(a?: number): number;
}): number[];
(x: {
(a: boolean): boolean;
(a?: boolean): boolean;
}): boolean[];
};
var a17: {
(x: {
<T extends Derived>(a: T): T;
<T extends Base>(a: T): T;
}): any[];
(x: {
<T extends Derived2>(a: T): T;
<T extends Base>(a: T): T;
}): any[];
};
var b2: <T, U>(x: T) => U[];
a2 = b2;
b2 = a2;
var b7: <T extends Base, U extends Derived, V extends Derived2>(x: (arg: T) => U) => (r: T) => V;
a7 = b7;
b7 = a7;
var b8: <T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: { foo: number; }) => U) => (r: T) => U;
a8 = b8; // error, { foo: number } and Base are incompatible
b8 = a8; // error, { foo: number } and Base are incompatible
var b10: <T extends Derived>(...x: T[]) => T;
a10 = b10;
b10 = a10;
var b11: <T extends Derived>(x: T, y: T) => T;
a11 = b11;
b11 = a11;
var b12: <T extends Array<Derived2>>(x: Array<Base>, y: Array<Base>) => T;
a12 = b12;
b12 = a12;
var b15: <T>(x: { a: T; b: T }) => T;
a15 = b15;
b15 = a15;
var b15a: <T extends Base>(x: { a: T; b: T }) => number;
a15 = b15a;
b15a = a15;
var b16: <T>(x: (a: T) => T) => T[];
a16 = b16;
b16 = a16;
var b17: <T>(x: (a: T) => T) => any[];
a17 = b17;
b17 = a17;
}
module WithGenericSignaturesInBaseType {
// target type has generic call signature
var a2: <T>(x: T) => T[];
var b2: <T>(x: T) => string[];
a2 = b2;
b2 = a2;
// target type has generic call signature
var a3: <T>(x: T) => string[];
var b3: <T>(x: T) => T[];
a3 = b3;
b3 = a3;
}
} | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/assignmentCompatWithCallSignatures5.ts | TypeScript | // checking assignment compat for function types. No errors in this file
class Base { foo: string; }
class Derived extends Base { bar: string; }
class Derived2 extends Derived { baz: string; }
class OtherDerived extends Base { bing: string; }
var a: <T>(x: T) => T[];
var a2: <T>(x: T) => string[];
var a3: <T>(x: T) => void;
var a4: <T,U>(x: T, y: U) => string;
var a5: <T,U>(x: (arg: T) => U) => T;
var a6: <T extends Base>(x: (arg: T) => Derived) => T;
var a11: <T>(x: { foo: T }, y: { foo: T; bar: T }) => Base;
var a15: <T>(x: { a: T; b: T }) => T[];
var a16: <T extends Base>(x: { a: T; b: T }) => T[];
var a17: {
<T extends Derived>(x: (a: T) => T): T[];
<T extends Base>(x: (a: T) => T): T[];
};
var a18: {
(x: {
<T extends Derived>(a: T): T;
<T extends Base>(a: T): T;
}): any[];
(x: {
<T extends Derived2>(a: T): T;
<T extends Base>(a: T): T;
}): any[];
};
var b: <T>(x: T) => T[];
a = b; // ok
b = a; // ok
var b2: <T>(x: T) => string[];
a2 = b2; // ok
b2 = a2; // ok
var b3: <T>(x: T) => T;
a3 = b3; // ok
b3 = a3; // ok
var b4: <T, U>(x: T, y: U) => string;
a4 = b4; // ok
b4 = a4; // ok
var b5: <T, U>(x: (arg: T) => U) => T;
a5 = b5; // ok
b5 = a5; // ok
var b6: <T extends Base, U extends Derived>(x: (arg: T) => U) => T;
a6 = b6; // ok
b6 = a6; // ok
var b11: <T, U>(x: { foo: T }, y: { foo: U; bar: U }) => Base;
a11 = b11; // ok
b11 = a11; // ok
var b15: <U, V>(x: { a: U; b: V; }) => U[];
a15 = b15; // ok, T = U, T = V
b15 = a15; // ok
var b16: <T>(x: { a: T; b: T }) => T[];
a15 = b16; // ok
b15 = a16; // ok
var b17: <T>(x: (a: T) => T) => T[];
a17 = b17; // ok
b17 = a17; // ok
var b18: (x: <T>(a: T) => T) => any[];
a18 = b18; // ok
b18 = a18; // ok
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/assignmentCompatWithCallSignatures6.ts | TypeScript | // checking assignment compatibility relations for function types. All valid
class Base { foo: string; }
class Derived extends Base { bar: string; }
class Derived2 extends Derived { baz: string; }
class OtherDerived extends Base { bing: string; }
interface A {
a: <T>(x: T) => T[];
a2: <T>(x: T) => string[];
a3: <T>(x: T) => void;
a4: <T,U>(x: T, y: U) => string;
a5: <T,U>(x: (arg: T) => U) => T;
a6: <T extends Base>(x: (arg: T) => Derived) => T;
a11: <T>(x: { foo: T }, y: { foo: T; bar: T }) => Base;
a15: <T>(x: { a: T; b: T }) => T[];
a16: <T extends Base>(x: { a: T; b: T }) => T[];
}
var x: A;
var b: <T>(x: T) => T[];
x.a = b;
b = x.a;
var b2: <T>(x: T) => string[];
x.a2 = b2;
b2 = x.a2;
var b3: <T>(x: T) => T;
x.a3 = b3;
b3 = x.a3;
var b4: <T, U>(x: T, y: U) => string;
x.a4 = b4;
b4 = x.a4;
var b5: <T, U>(x: (arg: T) => U) => T;
x.a5 = b5;
b5 = x.a5;
var b11: <T, U>(x: { foo: T }, y: { foo: U; bar: U }) => Base;
x.a11 = b11;
b11 = x.a11;
var b16: <T>(x: { a: T; b: T }) => T[];
x.a16 = b16;
b16 = x.a16; | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/assignmentCompatWithCallSignaturesWithOptionalParameters.ts | TypeScript | // call signatures in derived types must have the same or fewer optional parameters as the base type
interface Base {
a: () => number;
a2: (x?: number) => number;
a3: (x: number) => number;
a4: (x: number, y?: number) => number;
a5: (x?: number, y?: number) => number;
a6: (x: number, y: number) => number;
}
var b: Base;
var a: () => number;
a = () => 1 // ok, same number of required params
a = (x?: number) => 1; // ok, same number of required params
a = (x: number) => 1; // error, too many required params
a = b.a; // ok
a = b.a2; // ok
a = b.a3; // error
a = b.a4; // error
a = b.a5; // ok
a = b.a6; // error
var a2: (x?: number) => number;
a2 = () => 1; // ok, same number of required params
a2 = (x?: number) => 1; // ok, same number of required params
a2 = (x: number) => 1; // ok, same number of params
a2 = b.a; // ok
a2 = b.a2; // ok
a2 = b.a3; // ok, same number of params
a2 = b.a4; // ok, excess params are optional in b.a3
a2 = b.a5; // ok
a2 = b.a6; // error
var a3: (x: number) => number;
a3 = () => 1; // ok, fewer required params
a3 = (x?: number) => 1; // ok, fewer required params
a3 = (x: number) => 1; // ok, same number of required params
a3 = (x: number, y: number) => 1; // error, too many required params
a3 = b.a; // ok
a3 = b.a2; // ok
a3 = b.a3; // ok
a3 = b.a4; // ok
a3 = b.a5; // ok
a3 = b.a6; // error
var a4: (x: number, y?: number) => number;
a4 = () => 1; // ok, fewer required params
a4 = (x?: number, y?: number) => 1; // ok, fewer required params
a4 = (x: number) => 1; // ok, same number of required params
a4 = (x: number, y: number) => 1; // ok, same number of params
a4 = b.a; // ok
a4 = b.a2; // ok
a4 = b.a3; // ok
a4 = b.a4; // ok
a4 = b.a5; // ok
a4 = b.a6; // ok, same number of params
var a5: (x?: number, y?: number) => number;
a5 = () => 1; // ok, fewer required params
a5 = (x?: number, y?: number) => 1; // ok, fewer required params
a5 = (x: number) => 1; // ok, fewer params in lambda
a5 = (x: number, y: number) => 1; // ok, same number of params
a5 = b.a; // ok
a5 = b.a2; // ok
a5 = b.a3; // ok, fewer params in b.a3
a5 = b.a4; // ok, same number of params
a5 = b.a5; // ok
a5 = b.a6; // ok, same number of params | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/assignmentCompatWithCallSignaturesWithRestParameters.ts | TypeScript | // call signatures in derived types must have the same or fewer optional parameters as the target for assignment
interface Base {
a: (...args: number[]) => number;
a2: (x: number, ...z: number[]) => number;
a3: (x: number, y?: string, ...z: number[]) => number;
a4: (x?: number, y?: string, ...z: number[]) => number;
}
var a: (...args: number[]) => number; // ok, same number of required params
a = () => 1; // ok, same number of required params
a = (...args: number[]) => 1; // ok, same number of required params
a = (...args: string[]) => 1; // error, type mismatch
a = (x?: number) => 1; // ok, same number of required params
a = (x?: number, y?: number, z?: number) => 1; // ok, same number of required params
a = (x: number) => 1; // ok, rest param corresponds to infinite number of params
a = (x?: string) => 1; // error, incompatible type
var a2: (x: number, ...z: number[]) => number;
a2 = () => 1; // ok, fewer required params
a2 = (...args: number[]) => 1; // ok, fewer required params
a2 = (x?: number) => 1; // ok, fewer required params
a2 = (x: number) => 1; // ok, same number of required params
a2 = (x: number, ...args: number[]) => 1; // ok, same number of required params
a2 = (x: number, ...args: string[]) => 1; // should be type mismatch error
a2 = (x: number, y: number) => 1; // ok, rest param corresponds to infinite number of params
a2 = (x: number, y?: number) => 1; // ok, same number of required params
var a3: (x: number, y?: string, ...z: number[]) => number;
a3 = () => 1; // ok, fewer required params
a3 = (x?: number) => 1; // ok, fewer required params
a3 = (x: number) => 1; // ok, same number of required params
a3 = (x: number, y: string) => 1; // ok, all present params match
a3 = (x: number, y?: number, z?: number) => 1; // error
a3 = (x: number, ...z: number[]) => 1; // error
a3 = (x: string, y?: string, z?: string) => 1; // error
var a4: (x?: number, y?: string, ...z: number[]) => number;
a4 = () => 1; // ok, fewer required params
a4 = (x?: number, y?: number) => 1; // error, type mismatch
a4 = (x: number) => 1; // ok, all present params match
a4 = (x: number, y?: number) => 1; // error, second param has type mismatch
a4 = (x?: number, y?: string) => 1; // ok, same number of required params with matching types
a4 = (x: number, ...args: string[]) => 1; // error, rest params have type mismatch | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/assignmentCompatWithConstructSignatures.ts | TypeScript | // void returning call signatures can be assigned a non-void returning call signature that otherwise matches
interface T {
new (x: number): void;
}
var t: T;
var a: { new (x: number): void };
t = a;
a = t;
interface S {
new (x: number): string;
}
var s: S;
var a2: { new (x: number): string };
t = s;
t = a2;
a = s;
a = a2;
interface S2 {
(x: string): void;
}
var s2: S2;
var a3: { (x: string): void };
// these are errors
t = s2;
t = a3;
t = (x: string) => 1;
t = function (x: string) { return ''; }
a = s2;
a = a3;
a = (x: string) => 1;
a = function (x: string) { return ''; }
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/assignmentCompatWithConstructSignatures2.ts | TypeScript | // void returning call signatures can be assigned a non-void returning call signature that otherwise matches
interface T {
f: new (x: number) => void;
}
var t: T;
var a: { f: new (x: number) => void };
t = a;
a = t;
interface S {
f: new (x: number) => string;
}
var s: S;
var a2: { f: new (x: number) => string };
t = s;
t = a2;
a = s;
a = a2;
// errors
t = () => 1;
t = function (x: number) { return ''; }
a = () => 1;
a = function (x: number) { return ''; }
interface S2 {
f(x: string): void;
}
var s2: S2;
var a3: { f(x: string): void };
// these are errors
t = s2;
t = a3;
t = (x: string) => 1;
t = function (x: string) { return ''; }
a = s2;
a = a3;
a = (x: string) => 1;
a = function (x: string) { return ''; }
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/assignmentCompatWithConstructSignatures3.ts | TypeScript | // checking assignment compatibility relations for function types. All of these are valid.
class Base { foo: string; }
class Derived extends Base { bar: string; }
class Derived2 extends Derived { baz: string; }
class OtherDerived extends Base { bing: string; }
var a: new (x: number) => number[];
var a2: new (x: number) => string[];
var a3: new (x: number) => void;
var a4: new (x: string, y: number) => string;
var a5: new (x: (arg: string) => number) => string;
var a6: new (x: (arg: Base) => Derived) => Base;
var a7: new (x: (arg: Base) => Derived) => (r: Base) => Derived;
var a8: new (x: (arg: Base) => Derived, y: (arg2: Base) => Derived) => (r: Base) => Derived;
var a9: new (x: (arg: Base) => Derived, y: (arg2: Base) => Derived) => (r: Base) => Derived;
var a10: new (...x: Derived[]) => Derived;
var a11: new (x: { foo: string }, y: { foo: string; bar: string }) => Base;
var a12: new (x: Array<Base>, y: Array<Derived2>) => Array<Derived>;
var a13: new (x: Array<Base>, y: Array<Derived>) => Array<Derived>;
var a14: new (x: { a: string; b: number }) => Object;
var a15: {
new (x: number): number[];
new (x: string): string[];
}
var a16: {
new <T extends Derived>(x: T): number[];
new <U extends Base>(x: U): number[];
}
var a17: {
new (x: new (a: number) => number): number[];
new (x: new (a: string) => string): string[];
};
var a18: {
new (x: {
new (a: number): number;
new (a: string): string;
}): any[];
new (x: {
new (a: boolean): boolean;
new (a: Date): Date;
}): any[];
}
var b: new <T>(x: T) => T[];
a = b; // ok
b = a; // ok
var b2: new <T>(x: T) => string[];
a2 = b2; // ok
b2 = a2; // ok
var b3: new <T>(x: T) => T;
a3 = b3; // ok
b3 = a3; // ok
var b4: new <T, U>(x: T, y: U) => T;
a4 = b4; // ok
b4 = a4; // ok
var b5: new <T, U>(x: (arg: T) => U) => T;
a5 = b5; // ok
b5 = a5; // ok
var b6: new <T extends Base, U extends Derived>(x: (arg: T) => U) => T;
a6 = b6; // ok
b6 = a6; // ok
var b7: new <T extends Base, U extends Derived>(x: (arg: T) => U) => (r: T) => U;
a7 = b7; // ok
b7 = a7; // ok
var b8: new <T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: T) => U) => (r: T) => U;
a8 = b8; // ok
b8 = a8; // ok
var b9: new <T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: { foo: string; bing: number }) => U) => (r: T) => U;
a9 = b9; // ok
b9 = a9; // ok
var b10: new <T extends Derived>(...x: T[]) => T;
a10 = b10; // ok
b10 = a10; // ok
var b11: new <T extends Base>(x: T, y: T) => T;
a11 = b11; // ok
b11 = a11; // ok
var b12: new <T extends Array<Base>>(x: Array<Base>, y: T) => Array<Derived>;
a12 = b12; // ok
b12 = a12; // ok
var b13: new <T extends Array<Derived>>(x: Array<Base>, y: T) => T;
a13 = b13; // ok
b13 = a13; // ok
var b14: new <T>(x: { a: T; b: T }) => T;
a14 = b14; // ok
b14 = a14; // ok
var b15: new <T>(x: T) => T[];
a15 = b15; // ok
b15 = a15; // ok
var b16: new <T extends Base>(x: T) => number[];
a16 = b16; // ok
b16 = a16; // ok
var b17: new <T>(x: new (a: T) => T) => T[]; // ok
a17 = b17; // ok
b17 = a17; // ok
var b18: new <T>(x: new (a: T) => T) => T[];
a18 = b18; // ok
b18 = a18; // ok
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/assignmentCompatWithConstructSignatures4.ts | TypeScript | // checking assignment compatibility relations for function types.
module Errors {
class Base { foo: string; }
class Derived extends Base { bar: string; }
class Derived2 extends Derived { baz: string; }
class OtherDerived extends Base { bing: string; }
module WithNonGenericSignaturesInBaseType {
// target type with non-generic call signatures
var a2: new (x: number) => string[];
var a7: new (x: (arg: Base) => Derived) => (r: Base) => Derived2;
var a8: new (x: (arg: Base) => Derived, y: (arg2: Base) => Derived) => (r: Base) => Derived;
var a10: new (...x: Base[]) => Base;
var a11: new (x: { foo: string }, y: { foo: string; bar: string }) => Base;
var a12: new (x: Array<Base>, y: Array<Derived2>) => Array<Derived>;
var a14: {
new (x: number): number[];
new (x: string): string[];
};
var a15: new (x: { a: string; b: number }) => number;
var a16: {
new (x: {
new (a: number): number;
new (a?: number): number;
}): number[];
new (x: {
new (a: boolean): boolean;
new (a?: boolean): boolean;
}): boolean[];
};
var a17: {
new (x: {
new <T extends Derived>(a: T): T;
new <T extends Base>(a: T): T;
}): any[];
new (x: {
new <T extends Derived2>(a: T): T;
new <T extends Base>(a: T): T;
}): any[];
};
var b2: new <T, U>(x: T) => U[];
a2 = b2; // ok
b2 = a2; // ok
var b7: new <T extends Base, U extends Derived, V extends Derived2>(x: (arg: T) => U) => (r: T) => V;
a7 = b7; // ok
b7 = a7; // ok
var b8: new <T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: { foo: number; }) => U) => (r: T) => U;
a8 = b8; // error, type mismatch
b8 = a8; // error
var b10: new <T extends Derived>(...x: T[]) => T;
a10 = b10; // ok
b10 = a10; // ok
var b11: new <T extends Derived>(x: T, y: T) => T;
a11 = b11; // ok
b11 = a11; // ok
var b12: new <T extends Array<Derived2>>(x: Array<Base>, y: Array<Base>) => T;
a12 = b12; // ok
b12 = a12; // ok
var b15: new <T>(x: { a: T; b: T }) => T;
a15 = b15; // ok
b15 = a15; // ok
var b15a: new <T extends Base>(x: { a: T; b: T }) => number;
a15 = b15a; // ok
b15a = a15; // ok
var b16: new <T>(x: (a: T) => T) => T[];
a16 = b16; // error
b16 = a16; // error
var b17: new <T>(x: (a: T) => T) => any[];
a17 = b17; // error
b17 = a17; // error
}
module WithGenericSignaturesInBaseType {
// target type has generic call signature
var a2: new <T>(x: T) => T[];
var b2: new <T>(x: T) => string[];
a2 = b2; // ok
b2 = a2; // ok
// target type has generic call signature
var a3: new <T>(x: T) => string[];
var b3: new <T>(x: T) => T[];
a3 = b3; // ok
b3 = a3; // ok
}
} | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/assignmentCompatWithConstructSignatures5.ts | TypeScript | // checking assignment compat for function types. All valid
class Base { foo: string; }
class Derived extends Base { bar: string; }
class Derived2 extends Derived { baz: string; }
class OtherDerived extends Base { bing: string; }
var a: new <T>(x: T) => T[];
var a2: new <T>(x: T) => string[];
var a3: new <T>(x: T) => void;
var a4: new <T, U>(x: T, y: U) => string;
var a5: new <T, U>(x: new (arg: T) => U) => T;
var a6: new <T extends Base>(x: new (arg: T) => Derived) => T;
var a11: new <T>(x: { foo: T }, y: { foo: T; bar: T }) => Base;
var a15: new <T>(x: { a: T; b: T }) => T[];
var a16: new <T extends Base>(x: { a: T; b: T }) => T[];
var a17: {
new <T extends Derived>(x: new (a: T) => T): T[];
new <T extends Base>(x: new (a: T) => T): T[];
};
var a18: {
new (x: {
new <T extends Derived>(a: T): T;
new <T extends Base>(a: T): T;
}): any[];
new (x: {
new <T extends Derived2>(a: T): T;
new <T extends Base>(a: T): T;
}): any[];
};
var b: new <T>(x: T) => T[];
a = b; // ok
b = a; // ok
var b2: new <T>(x: T) => string[];
a2 = b2; // ok
b2 = a2; // ok
var b3: new <T>(x: T) => T;
a3 = b3; // ok
b3 = a3; // ok
var b4: new <T, U>(x: T, y: U) => string;
a4 = b4; // ok
b4 = a4; // ok
var b5: new <T, U>(x: new (arg: T) => U) => T;
a5 = b5; // ok
b5 = a5; // ok
var b6: new <T extends Base, U extends Derived>(x: new (arg: T) => U) => T;
a6 = b6; // ok
b6 = a6; // ok
var b11: new <T, U>(x: { foo: T }, y: { foo: U; bar: U }) => Base;
a11 = b11; // ok
b11 = a11; // ok
var b15: new <U, V>(x: { a: U; b: V; }) => U[];
a15 = b15; // ok
b15 = a15; // ok
var b16: new <T>(x: { a: T; b: T }) => T[];
a15 = b16; // ok
b15 = a16; // ok
var b17: new <T>(x: new (a: T) => T) => T[];
a17 = b17; // ok
b17 = a17; // ok
var b18: new (x: new <T>(a: T) => T) => any[];
a18 = b18; // ok
b18 = a18; // ok
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/assignmentCompatWithConstructSignatures6.ts | TypeScript | // checking assignment compatibility relations for function types. All valid.
class Base { foo: string; }
class Derived extends Base { bar: string; }
class Derived2 extends Derived { baz: string; }
class OtherDerived extends Base { bing: string; }
interface A {
a: new <T>(x: T) => T[];
a2: new <T>(x: T) => string[];
a3: new <T>(x: T) => void;
a4: new <T, U>(x: T, y: U) => string;
a5: new <T, U>(x: (arg: T) => U) => T;
a6: new <T extends Base>(x: (arg: T) => Derived) => T;
a11: new <T>(x: { foo: T }, y: { foo: T; bar: T }) => Base;
a15: new <T>(x: { a: T; b: T }) => T[];
a16: new <T extends Base>(x: { a: T; b: T }) => T[];
}
var x: A;
var b: new <T>(x: T) => T[];
x.a = b;
b = x.a;
var b2: new <T>(x: T) => string[];
x.a2 = b2;
b2 = x.a2;
var b3: new <T>(x: T) => T;
x.a3 = b3;
b3 = x.a3;
var b4: new <T, U>(x: T, y: U) => string;
x.a4 = b4;
b4 = x.a4;
var b5: new <T, U>(x: (arg: T) => U) => T;
x.a5 = b5;
b5 = x.a5;
var b11: new <T, U>(x: { foo: T }, y: { foo: U; bar: U }) => Base;
x.a11 = b11;
b11 = x.a11;
var b16: new <T>(x: { a: T; b: T }) => T[];
x.a16 = b16;
b16 = x.a16; | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/assignmentCompatWithConstructSignaturesWithOptionalParameters.ts | TypeScript | // call signatures in derived types must have the same or fewer optional parameters as the base type
interface Base {
a: new () => number;
a2: new (x?: number) => number;
a3: new (x: number) => number;
a4: new (x: number, y?: number) => number;
a5: new (x?: number, y?: number) => number;
a6: new (x: number, y: number) => number;
}
var b: Base;
var a: new () => number;
a = b.a; // ok
a = b.a2; // ok
a = b.a3; // error
a = b.a4; // error
a = b.a5; // ok
a = b.a6; // error
var a2: new (x?: number) => number;
a2 = b.a; // ok
a2 = b.a2; // ok
a2 = b.a3; // ok
a2 = b.a4; // ok
a2 = b.a5; // ok
a2 = b.a6; // error
var a3: new (x: number) => number;
a3 = b.a; // ok
a3 = b.a2; // ok
a3 = b.a3; // ok
a3 = b.a4; // ok
a3 = b.a5; // ok
a3 = b.a6; // error
var a4: new (x: number, y?: number) => number;
a4 = b.a; // ok
a4 = b.a2; // ok
a4 = b.a3; // ok
a4 = b.a4; // ok
a4 = b.a5; // ok
a4 = b.a6; // ok
var a5: new (x?: number, y?: number) => number;
a5 = b.a; // ok
a5 = b.a2; // ok
a5 = b.a3; // ok
a5 = b.a4; // ok
a5 = b.a5; // ok
a5 = b.a6; // ok
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/assignmentCompatWithDiscriminatedUnion.ts | TypeScript | // see 'typeRelatedToDiscriminatedType' in checker.ts:
// IteratorResult
namespace Example1 {
type S = { done: boolean, value: number };
type T =
| { done: true, value: number } // T0
| { done: false, value: number }; // T1
declare let s: S;
declare let t: T;
// S is assignable to T0 when S["done"] is true
// S is assignable to T1 when S["done"] is false
t = s;
}
// Dropping constituents of T
namespace Example2 {
type S = { a: 0 | 2, b: 4 };
type T = { a: 0, b: 1 | 4 } // T0
| { a: 1, b: 2 } // T1
| { a: 2, b: 3 | 4 }; // T2
declare let s: S;
declare let t: T;
// S is assignable to T0 when S["a"] is 0
// S is assignable to T2 when S["a"] is 2
t = s;
}
// Unmatched discriminants
namespace Example3 {
type S = { a: 0 | 2, b: 4 };
type T = { a: 0, b: 1 | 4 } // T0
| { a: 1, b: 2 | 4 } // T1
| { a: 2, b: 3 }; // T2
declare let s: S;
declare let t: T;
// S is assignable to T0 when S["a"] is 0
// S is *not* assignable to T1 when S["b"] is 4
// S is *not* assignable to T2 when S["a"] is 2
t = s;
}
// Unmatched non-discriminants
namespace Example4 {
type S = { a: 0 | 2, b: 4 };
type T = { a: 0, b: 1 | 4 } // T0
| { a: 1, b: 2 } // T1
| { a: 2, b: 3 | 4, c: string }; // T2
declare let s: S;
declare let t: T;
// S is assignable to T0 when S["a"] is 0
// S is *not* assignable to T2 when S["a"] is 2 as S is missing "c"
t = s;
}
// Maximum discriminant combinations
namespace Example5 {
// NOTE: The maximum number of discriminant type combinations is currently 25.
// 3 discriminant properties with 3 types a piece
// is 27 possible combinations.
type N = 0 | 1 | 2;
type S = { a: N, b: N, c: N };
type T = { a: 0, b: N, c: N }
| { a: 1, b: N, c: N }
| { a: 2, b: N, c: N }
| { a: N, b: 0, c: N }
| { a: N, b: 1, c: N }
| { a: N, b: 2, c: N }
| { a: N, b: N, c: 0 }
| { a: N, b: N, c: 1 }
| { a: N, b: N, c: 2 };
declare let s: S;
declare let t: T;
// S *should* be assignable but the number of
// combinations is too complex.
t = s;
}
// https://github.com/Microsoft/TypeScript/issues/14865
namespace GH14865 {
type Style1 = {
type: "A";
data: string;
} | {
type: "B";
data: string;
};
type Style2 = {
type: "A" | "B";
data: string;
}
const a: Style2 = { type: "A", data: "whatevs" };
let b: Style1;
a.type; // "A" | "B"
b.type; // "A" | "B"
b = a; // should be assignable
}
// https://github.com/Microsoft/TypeScript/issues/30170
namespace GH30170 {
interface Blue {
color: 'blue'
}
interface Yellow {
color?: 'yellow',
}
function draw(val: Blue | Yellow) { }
function drawWithColor(currentColor: 'blue' | 'yellow' | undefined) {
return draw({ color: currentColor });
}
}
// https://github.com/Microsoft/TypeScript/issues/12052
namespace GH12052 {
interface ILinearAxis { type: "linear"; }
interface ICategoricalAxis { type: "categorical"; }
type IAxis = ILinearAxis | ICategoricalAxis;
type IAxisType = "linear" | "categorical";
function getAxisType(): IAxisType {
if (1 == 1) {
return "categorical";
} else {
return "linear";
}
}
const bad: IAxis = { type: getAxisType() };
const good: IAxis = { type: undefined };
good.type = getAxisType();
}
// https://github.com/Microsoft/TypeScript/issues/18421
namespace GH18421 {
interface ThingTypeOne {
type: 'one';
}
interface ThingTypeTwo {
type: 'two';
}
type ThingType = 'one' | 'two';
type Thing = ThingTypeOne | ThingTypeTwo;
function makeNewThing(thingType: ThingType): Thing {
return {
type: thingType
};
}
}
// https://github.com/Microsoft/TypeScript/issues/15907
namespace GH15907 {
type Action = { type: 'activate' } | { type: 'disactivate' };
function dispatchAction(action: Action): void {
}
const active = true;
dispatchAction({ type : (active? 'disactivate' : 'activate') });
}
// https://github.com/Microsoft/TypeScript/issues/20889
namespace GH20889 {
interface A1 {
type: "A1";
}
interface A2 {
type: "A2";
}
type AU = A1 | A2;
function foo(obj1: AU) {
const obj2: AU = {
type: obj1.type
};
}
}
// https://github.com/microsoft/TypeScript/issues/39357
namespace GH39357 {
type A = ["a", number] | ["b", number] | ["c", string];
type B = "a" | "b" | "c";
declare const b: B;
const a: A = b === "a" || b === "b" ? [b, 1] : ["c", ""];
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/assignmentCompatWithEnumIndexer.ts | TypeScript | enum E {
A
}
let foo: Record<E, any> = {}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/assignmentCompatWithGenericCallSignatures.ts | TypeScript | // some complex cases of assignment compat of generic signatures that stress contextual signature instantiation
var f: <S extends { p: string }[]>(x: S) => void
var g: <T extends { p: string }>(x: T[]) => void
f = g; // ok
g = f; // ok | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/assignmentCompatWithGenericCallSignatures2.ts | TypeScript | // some complex cases of assignment compat of generic signatures. No contextual signature instantiation
interface A {
<T>(x: T, ...y: T[][]): void
}
interface B {
<S>(x: S, ...y: S[]): void
}
var a: A;
var b: B;
// Both errors
a = b;
b = a;
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/assignmentCompatWithGenericCallSignatures3.ts | TypeScript | // some complex cases of assignment compat of generic signatures that stress contextual signature instantiation
interface I<T, S> {
<U>(f: (x: T) => (y: S) => U): U
}
var g: <T>(x: T) => <S>(y: S) => I<T, S>
var h: <T>(x: T) => <S>(y: S) => { <U>(f: (x: T) => (y: S) => U): U }
g = h // ok | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/assignmentCompatWithGenericCallSignatures4.ts | TypeScript | // some complex cases of assignment compat of generic signatures.
interface I2<T> {
p: T
}
var x: <T extends I2<T>>(z: T) => void
var y: <T extends I2<I2<T>>>(z: T) => void
// These both do not make sense as we would eventually be comparing I2<T> to I2<I2<T>>, and they are self referencing anyway
x = y
y = x
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts | TypeScript | // call signatures in derived types must have the same or fewer optional parameters as the target for assignment
module ClassTypeParam {
class Base<T> {
a: () => T;
a2: (x?: T) => T;
a3: (x: T) => T;
a4: (x: T, y?: T) => T;
a5: (x?: T, y?: T) => T;
init = () => {
this.a = () => null; // ok, same T of required params
this.a = (x?: T) => null; // ok, same T of required params
this.a = (x: T) => null; // error, too many required params
this.a2 = () => null; // ok, same T of required params
this.a2 = (x?: T) => null; // ok, same T of required params
this.a2 = (x: T) => null; // ok, same number of params
this.a3 = () => null; // ok, fewer required params
this.a3 = (x?: T) => null; // ok, fewer required params
this.a3 = (x: T) => null; // ok, same T of required params
this.a3 = (x: T, y: T) => null; // error, too many required params
this.a4 = () => null; // ok, fewer required params
this.a4 = (x?: T, y?: T) => null; // ok, fewer required params
this.a4 = (x: T) => null; // ok, same T of required params
this.a4 = (x: T, y: T) => null; // ok, same number of params
this.a5 = () => null; // ok, fewer required params
this.a5 = (x?: T, y?: T) => null; // ok, fewer required params
this.a5 = (x: T) => null; // ok, all present params match
this.a5 = (x: T, y: T) => null; // ok, same number of params
}
}
}
module GenericSignaturesInvalid {
class Base2 {
a: <T>() => T;
a2: <T>(x?: T) => T;
a3: <T>(x: T) => T;
a4: <T>(x: T, y?: T) => T;
a5: <T>(x?: T, y?: T) => T;
}
class Target<T> {
a: () => T;
a2: (x?: T) => T;
a3: (x: T) => T;
a4: (x: T, y?: T) => T;
a5: (x?: T, y?: T) => T;
}
function foo<T>() {
var b: Base2;
var t: Target<T>;
// all errors
b.a = t.a;
b.a = t.a2;
b.a = t.a3;
b.a = t.a4;
b.a = t.a5;
b.a2 = t.a;
b.a2 = t.a2;
b.a2 = t.a3;
b.a2 = t.a4;
b.a2 = t.a5;
b.a3 = t.a;
b.a3 = t.a2;
b.a3 = t.a3;
b.a3 = t.a4;
b.a3 = t.a5;
b.a4 = t.a;
b.a4 = t.a2;
b.a4 = t.a3;
b.a4 = t.a4;
b.a4 = t.a5;
b.a5 = t.a;
b.a5 = t.a2;
b.a5 = t.a3;
b.a5 = t.a4;
b.a5 = t.a5;
}
}
module GenericSignaturesValid {
class Base2 {
a: <T>() => T;
a2: <T>(x?: T) => T;
a3: <T>(x: T) => T;
a4: <T>(x: T, y?: T) => T;
a5: <T>(x?: T, y?: T) => T;
init = () => {
this.a = <T>() => null; // ok, same T of required params
this.a = <T>(x?: T) => null; // ok, same T of required params
this.a = <T>(x: T) => null; // error, too many required params
this.a2 = <T>() => null; // ok, same T of required params
this.a2 = <T>(x?: T) => null; // ok, same T of required params
this.a2 = <T>(x: T) => null; // ok, same number of params
this.a3 = <T>() => null; // ok, fewer required params
this.a3 = <T>(x?: T) => null; // ok, fewer required params
this.a3 = <T>(x: T) => null; // ok, same T of required params
this.a3 = <T>(x: T, y: T) => null; // error, too many required params
this.a4 = <T>() => null; // ok, fewer required params
this.a4 = <T>(x?: T, y?: T) => null; // ok, fewer required params
this.a4 = <T>(x: T) => null; // ok, same T of required params
this.a4 = <T>(x: T, y: T) => null; // ok, same number of params
this.a5 = <T>() => null; // ok, fewer required params
this.a5 = <T>(x?: T, y?: T) => null; // ok, fewer required params
this.a5 = <T>(x: T) => null; // ok, all present params match
this.a5 = <T>(x: T, y: T) => null; // ok, same number of params
}
}
} | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/assignmentCompatWithNumericIndexer.ts | TypeScript | // Derived type indexer must be subtype of base type indexer
interface Base { foo: string; }
interface Derived extends Base { bar: string; }
interface Derived2 extends Derived { baz: string; }
class A {
[x: number]: Base;
}
var a: A;
var b: { [x: number]: Derived; }
a = b;
b = a; // error
var b2: { [x: number]: Derived2; }
a = b2;
b2 = a; // error
module Generics {
class A<T extends Base> {
[x: number]: T;
}
class B extends A<Base> {
[x: number]: Derived; // ok
}
function foo<T extends Base>() {
var a: A<T>;
var b: { [x: number]: Derived; }
a = b; // error
b = a; // error
var b2: { [x: number]: Derived2; }
a = b2; // error
b2 = a; // error
var b3: { [x: number]: T; }
a = b3; // ok
b3 = a; // ok
}
} | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/assignmentCompatWithNumericIndexer2.ts | TypeScript | // Derived type indexer must be subtype of base type indexer
interface Base { foo: string; }
interface Derived extends Base { bar: string; }
interface Derived2 extends Derived { baz: string; }
interface A {
[x: number]: Base;
}
var a: A;
var b: { [x: number]: Derived; }
a = b;
b = a; // error
var b2: { [x: number]: Derived2; }
a = b2;
b2 = a; // error
module Generics {
interface A<T extends Base> {
[x: number]: T;
}
interface B extends A<Base> {
[x: number]: Derived; // ok
}
function foo<T extends Base>() {
var a: A<T>;
var b: { [x: number]: Derived; }
a = b; // error
b = a; // error
var b2: { [x: number]: Derived2; }
a = b2; // error
b2 = a; // error
var b3: { [x: number]: T; }
a = b3; // ok
b3 = a; // ok
}
} | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/assignmentCompatWithNumericIndexer3.ts | TypeScript | // Derived type indexer must be subtype of base type indexer
interface Base { foo: string; }
interface Derived extends Base { bar: string; }
interface Derived2 extends Derived { baz: string; }
class A {
[x: number]: Derived;
}
var a: A;
var b: { [x: number]: Base; };
a = b; // error
b = a; // ok
class B2 extends A {
[x: number]: Derived2; // ok
}
var b2: { [x: number]: Derived2; };
a = b2; // ok
b2 = a; // error
module Generics {
class A<T extends Derived> {
[x: number]: T;
}
function foo<T extends Derived>() {
var a: A<T>;
var b: { [x: number]: Derived; };
a = b; // error
b = a; // ok
var b2: { [x: number]: T; };
a = b2; // ok
b2 = a; // ok
}
} | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/assignmentCompatWithObjectMembers.ts | TypeScript | // members N and M of types S and T have the same name, same accessibility, same optionality, and N is assignable M
// no errors expected
module SimpleTypes {
class S { foo: string; }
class T { foo: string; }
var s: S;
var t: T;
interface S2 { foo: string; }
interface T2 { foo: string; }
var s2: S2;
var t2: T2;
var a: { foo: string; }
var b: { foo: string; }
var a2 = { foo: '' };
var b2 = { foo: '' };
s = t;
t = s;
s = s2;
s = a2;
s2 = t2;
t2 = s2;
s2 = t;
s2 = b;
s2 = a2;
a = b;
b = a;
a = s;
a = s2;
a = a2;
a2 = b2;
b2 = a2;
a2 = b;
a2 = t2;
a2 = t;
}
module ObjectTypes {
class S { foo: S; }
class T { foo: T; }
var s: S;
var t: T;
interface S2 { foo: S2; }
interface T2 { foo: T2; }
var s2: S2;
var t2: T2;
var a: { foo: typeof a; }
var b: { foo: typeof b; }
var a2 = { foo: a2 };
var b2 = { foo: b2 };
s = t;
t = s;
s = s2;
s = a2;
s2 = t2;
t2 = s2;
s2 = t;
s2 = b;
s2 = a2;
a = b;
b = a;
a = s;
a = s2;
a = a2;
a2 = b2;
b2 = a2;
a2 = b;
a2 = t2;
a2 = t;
} | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/assignmentCompatWithObjectMembers2.ts | TypeScript | // members N and M of types S and T have the same name, same accessibility, same optionality, and N is assignable M
// additional optional properties do not cause errors
class S { foo: string; }
class T { foo: string; }
var s: S;
var t: T;
interface S2 { foo: string; bar?: string }
interface T2 { foo: string; baz?: string }
var s2: S2;
var t2: T2;
var a: { foo: string; bar?: string }
var b: { foo: string; baz?: string }
var a2 = { foo: '' };
var b2 = { foo: '' };
s = t;
t = s;
s = s2;
s = a2;
s2 = t2;
t2 = s2;
s2 = t;
s2 = b;
s2 = a2;
a = b;
b = a;
a = s;
a = s2;
a = a2;
a2 = b2;
b2 = a2;
a2 = b;
a2 = t2;
a2 = t;
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/assignmentCompatWithObjectMembers3.ts | TypeScript | // members N and M of types S and T have the same name, same accessibility, same optionality, and N is assignable M
// additional optional properties do not cause errors
class S implements S2 { foo: string; }
class T implements T2 { foo: string; }
var s: S;
var t: T;
interface S2 { foo: string; bar?: string }
interface T2 { foo: string; baz?: string }
var s2: S2;
var t2: T2;
var a: { foo: string; bar?: string }
var b: { foo: string; baz?: string }
var a2: S2 = { foo: '' };
var b2: T2 = { foo: '' };
s = t;
t = s;
s = s2;
s = a2;
s2 = t2;
t2 = s2;
s2 = t;
s2 = b;
s2 = a2;
a = b;
b = a;
a = s;
a = s2;
a = a2;
a2 = b2;
b2 = a2;
a2 = b;
a2 = t2;
a2 = t;
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/assignmentCompatWithObjectMembers4.ts | TypeScript | // members N and M of types S and T have the same name, same accessibility, same optionality, and N is not assignable M
module OnlyDerived {
class Base { foo: string; }
class Derived extends Base { bar: string; }
class Derived2 extends Base { baz: string; }
class S { foo: Derived; }
class T { foo: Derived2; }
var s: S;
var t: T;
interface S2 { foo: Derived; }
interface T2 { foo: Derived2; }
var s2: S2;
var t2: T2;
var a: { foo: Derived; }
var b: { foo: Derived2; }
var a2 = { foo: new Derived() };
var b2 = { foo: new Derived2() };
s = t; // error
t = s; // error
s = s2; // ok
s = a2; // ok
s2 = t2; // error
t2 = s2; // error
s2 = t; // error
s2 = b; // error
s2 = a2; // ok
a = b; // error
b = a; // error
a = s; // ok
a = s2; // ok
a = a2; // ok
a2 = b2; // error
b2 = a2; // error
a2 = b; // error
a2 = t2; // error
a2 = t; // error
}
module WithBase {
class Base { foo: string; }
class Derived extends Base { bar: string; }
class Derived2 extends Base { baz: string; }
class S { foo: Base; }
class T { foo: Derived2; }
var s: S;
var t: T;
interface S2 { foo: Base; }
interface T2 { foo: Derived2; }
var s2: S2;
var t2: T2;
var a: { foo: Base; }
var b: { foo: Derived2; }
var a2 = { foo: new Base() };
var b2 = { foo: new Derived2() };
s = t; // ok
t = s; // error
s = s2; // ok
s = a2; // ok
s2 = t2; // ok
t2 = s2; // error
s2 = t; // ok
s2 = b; // ok
s2 = a2; // ok
a = b; // ok
b = a; // error
a = s; // ok
a = s2; // ok
a = a2; // ok
a2 = b2; // ok
b2 = a2; // error
a2 = b; // ok
a2 = t2; // ok
a2 = t; // ok
} | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/assignmentCompatWithObjectMembers5.ts | TypeScript | class C {
foo: string;
}
var c: C;
interface I {
fooo: string;
}
var i: I;
c = i; // error
i = c; // error | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/assignmentCompatWithObjectMembersAccessibility.ts | TypeScript | // members N and M of types S and T have the same name, same accessibility, same optionality, and N is assignable M
module TargetIsPublic {
// targets
class Base {
public foo: string;
}
interface I {
foo: string;
}
var a: { foo: string; }
var b: Base;
var i: I;
// sources
class D {
public foo: string;
}
class E {
private foo: string;
}
var d: D;
var e: E;
a = b;
a = i;
a = d;
a = e; // error
b = a;
b = i;
b = d;
b = e; // error
i = a;
i = b;
i = d;
i = e; // error
d = a;
d = b;
d = i;
d = e; // error
e = a; // errror
e = b; // errror
e = i; // errror
e = d; // errror
e = e;
}
module TargetIsPublic {
// targets
class Base {
private foo: string;
}
interface I extends Base {
}
var a: { foo: string; }
var b: Base;
var i: I;
// sources
class D {
public foo: string;
}
class E {
private foo: string;
}
var d: D;
var e: E;
a = b; // error
a = i; // error
a = d;
a = e; // error
b = a; // error
b = i;
b = d; // error
b = e; // error
b = b;
i = a; // error
i = b;
i = d; // error
i = e; // error
i = i;
d = a;
d = b; // error
d = i; // error
d = e; // error
e = a; // errror
e = b; // errror
e = i; // errror
e = d; // errror
e = e;
} | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/assignmentCompatWithObjectMembersNumericNames.ts | TypeScript | // members N and M of types S and T have the same name, same accessibility, same optionality, and N is assignable M
// numeric named properties work correctly, no errors expected
class S { 1: string; }
class T { 1.: string; }
var s: S;
var t: T;
interface S2 { 1: string; bar?: string }
interface T2 { 1.0: string; baz?: string }
var s2: S2;
var t2: T2;
var a: { 1.: string; bar?: string }
var b: { 1.0: string; baz?: string }
var a2 = { 1.0: '' };
var b2 = { 1: '' };
s = t;
t = s;
s = s2;
s = a2;
s2 = t2;
t2 = s2;
s2 = t;
s2 = b;
s2 = a2;
a = b;
b = a;
a = s;
a = s2;
a = a2;
a2 = b2;
b2 = a2;
a2 = b;
a2 = t2;
a2 = t;
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/assignmentCompatWithObjectMembersOptionality.ts | TypeScript | // Derived member is not optional but base member is, should be ok
class Base { foo: string; }
class Derived extends Base { bar: string; }
class Derived2 extends Derived { baz: string; }
module TargetHasOptional {
// targets
interface C {
opt?: Base
}
var c: C;
var a: { opt?: Base; }
var b: typeof a = { opt: new Base() }
// sources
interface D {
opt: Base;
}
interface E {
opt: Derived;
}
interface F {
opt?: Derived;
}
var d: D;
var e: E;
var f: F;
// all ok
c = d;
c = e;
c = f;
c = a;
a = d;
a = e;
a = f;
a = c;
b = d;
b = e;
b = f;
b = a;
b = c;
}
module SourceHasOptional {
// targets
interface C {
opt: Base
}
var c: C;
var a: { opt: Base; }
var b = { opt: new Base() }
// sources
interface D {
opt?: Base;
}
interface E {
opt?: Derived;
}
interface F {
opt: Derived;
}
var d: D;
var e: E;
var f: F;
c = d; // error
c = e; // error
c = f; // ok
c = a; // ok
a = d; // error
a = e; // error
a = f; // ok
a = c; // ok
b = d; // error
b = e; // error
b = f; // ok
b = a; // ok
b = c; // ok
} | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/assignmentCompatWithObjectMembersOptionality2.ts | TypeScript | // M is optional and S contains no property with the same name as M
// N is optional and T contains no property with the same name as N
class Base { foo: string; }
class Derived extends Base { bar: string; }
class Derived2 extends Derived { baz: string; }
module TargetHasOptional {
// targets
interface C {
opt?: Base
}
var c: C;
var a: { opt?: Base; }
var b: typeof a = { opt: new Base() }
// sources
interface D {
other: Base;
}
interface E {
other: Derived;
}
interface F {
other?: Derived;
}
var d: D;
var e: E;
var f: F;
// disallowed by weak type checking
c = d;
c = e;
c = f;
a = d;
a = e;
a = f;
b = d;
b = e;
b = f;
// ok
c = a;
a = c;
b = a;
b = c;
}
module SourceHasOptional {
// targets
interface C {
opt: Base
}
var c: C;
var a: { opt: Base; }
var b = { opt: new Base() }
// sources
interface D {
other?: Base;
}
interface E {
other?: Derived;
}
interface F {
other: Derived;
}
var d: D;
var e: E;
var f: F;
c = d; // error
c = e; // error
c = f; // error
c = a; // ok
a = d; // error
a = e; // error
a = f; // error
a = c; // ok
b = d; // error
b = e; // error
b = f; // error
b = a; // ok
b = c; // ok
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/assignmentCompatWithObjectMembersStringNumericNames.ts | TypeScript | // members N and M of types S and T have the same name, same accessibility, same optionality, and N is assignable M
// string named numeric properties work correctly, errors below unless otherwise noted
module JustStrings {
class S { '1': string; }
class T { '1.': string; }
var s: S;
var t: T;
interface S2 { '1': string; bar?: string }
interface T2 { '1.0': string; baz?: string }
var s2: S2;
var t2: T2;
var a: { '1.': string; bar?: string }
var b: { '1.0': string; baz?: string }
var a2 = { '1.0': '' };
var b2 = { '1': '' };
s = t;
t = s;
s = s2; // ok
s = a2;
s2 = t2;
t2 = s2;
s2 = t;
s2 = b;
s2 = a2;
a = b;
b = a;
a = s;
a = s2;
a = a2;
a2 = b2;
b2 = a2;
a2 = b; // ok
a2 = t2; // ok
a2 = t;
}
module NumbersAndStrings {
class S { '1': string; }
class T { 1: string; }
var s: S;
var t: T;
interface S2 { '1': string; bar?: string }
interface T2 { 1.0: string; baz?: string }
var s2: S2;
var t2: T2;
var a: { '1.': string; bar?: string }
var b: { 1.0: string; baz?: string }
var a2 = { '1.0': '' };
var b2 = { 1.: '' };
s = t; // ok
t = s; // ok
s = s2; // ok
s = a2; // error
s2 = t2; // ok
t2 = s2; // ok
s2 = t; // ok
s2 = b; // ok
s2 = a2; // error
a = b; // error
b = a; // error
a = s; // error
a = s2; // error
a = a2; // error
a = b2; // error
a2 = b2; // error
b2 = a2; // error
a2 = b; // error
a2 = t2; // error
a2 = t; // error
} | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/assignmentCompatWithStringIndexer.ts | TypeScript | // index signatures must be compatible in assignments
interface Base { foo: string; }
interface Derived extends Base { bar: string; }
interface Derived2 extends Derived { baz: string; }
class A {
[x: string]: Base;
}
var a: A;
var b: { [x: string]: Derived; }
a = b; // ok
b = a; // error
var b2: { [x: string]: Derived2; }
a = b2; // ok
b2 = a; // error
module Generics {
class A<T extends Base> {
[x: string]: T;
}
class B extends A<Base> {
[x: string]: Derived; // ok
}
var b1: { [x: string]: Derived; };
var a1: A<Base>;
a1 = b1; // ok
b1 = a1; // error
class B2 extends A<Base> {
[x: string]: Derived2; // ok
}
var b2: { [x: string]: Derived2; };
a1 = b2; // ok
b2 = a1; // error
function foo<T extends Base>() {
var b3: { [x: string]: Derived; };
var a3: A<T>;
a3 = b3; // error
b3 = a3; // error
var b4: { [x: string]: Derived2; };
a3 = b4; // error
b4 = a3; // error
}
} | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/assignmentCompatWithStringIndexer2.ts | TypeScript | // index signatures must be compatible in assignments
interface Base { foo: string; }
interface Derived extends Base { bar: string; }
interface Derived2 extends Derived { baz: string; }
interface A {
[x: string]: Base;
}
var a: A;
var b: { [x: string]: Derived; }
a = b; // ok
b = a; // error
var b2: { [x: string]: Derived2; }
a = b2; // ok
b2 = a; // error
module Generics {
interface A<T extends Base> {
[x: string]: T;
}
interface B extends A<Base> {
[x: string]: Derived; // ok
}
var b1: { [x: string]: Derived; };
var a1: A<Base>;
a1 = b1; // ok
b1 = a1; // error
interface B2 extends A<Base> {
[x: string]: Derived2; // ok
}
var b2: { [x: string]: Derived2; };
a1 = b2; // ok
b2 = a1; // error
function foo<T extends Base>() {
var b3: { [x: string]: Derived; };
var a3: A<T>;
a3 = b3; // error
b3 = a3; // error
var b4: { [x: string]: Derived2; };
a3 = b4; // error
b4 = a3; // error
}
} | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/assignmentCompatWithStringIndexer3.ts | TypeScript | // Derived type indexer must be subtype of base type indexer
interface Base { foo: string; }
interface Derived extends Base { bar: string; }
interface Derived2 extends Derived { baz: string; }
var a: A;
var b1: { [x: string]: string; }
a = b1; // error
b1 = a; // error
module Generics {
class A<T extends Derived> {
[x: string]: T;
}
function foo<T extends Derived>() {
var a: A<T>;
var b: { [x: string]: string; }
a = b; // error
b = a; // error
}
} | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/assignmentGenericLookupTypeNarrowing.ts | TypeScript | // Repro from #26130
let mappedObject: {[K in "foo"]: null | {x: string}} = {foo: {x: "hello"}};
declare function foo<T>(x: T): null | T;
function bar<K extends "foo">(key: K) {
const element = foo(mappedObject[key]);
if (element == null)
return;
const x = element.x;
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/assignmentLHSIsReference.ts | TypeScript | var value: any;
// identifiers: variable and parameter
var x1: number;
x1 = value;
function fn1(x2: number) {
x2 = value;
}
// property accesses
var x3: { a: string };
x3.a = value;
x3['a'] = value;
// parentheses, the contained expression is reference
(x1) = value;
function fn2(x4: number) {
(x4) = value;
}
(x3.a) = value;
(x3['a']) = value; | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/assignmentToParenthesizedIdentifiers.ts | TypeScript | var x: number;
x = 3; // OK
(x) = 3; // OK
x = ''; // Error
(x) = ''; // Error
module M {
export var y: number;
}
M.y = 3; // OK
(M).y = 3; // OK
(M.y) = 3; // OK
M.y = ''; // Error
(M).y = ''; // Error
(M.y) = ''; // Error
M = { y: 3 }; // Error
(M) = { y: 3 }; // Error
module M2 {
export module M3 {
export var x: number;
}
M3 = { x: 3 }; // Error
}
M2.M3 = { x: 3 }; // OK
(M2).M3 = { x: 3 }; // OK
(M2.M3) = { x: 3 }; // OK
M2.M3 = { x: '' }; // Error
(M2).M3 = { x: '' }; // Error
(M2.M3) = { x: '' }; // Error
function fn() { }
fn = () => 3; // Bug 823548: Should be error (fn is not a reference)
(fn) = () => 3; // Should be error
function fn2(x: number, y: { t: number }) {
x = 3;
(x) = 3; // OK
x = ''; // Error
(x) = ''; // Error
(y).t = 3; // OK
(y.t) = 3; // OK
(y).t = ''; // Error
(y.t) = ''; // Error
y['t'] = 3; // OK
(y)['t'] = 3; // OK
(y['t']) = 3; // OK
y['t'] = ''; // Error
(y)['t'] = ''; // Error
(y['t']) = ''; // Error
}
enum E {
A
}
E = undefined; // Error
(E) = undefined; // Error
class C {
}
C = undefined; // Error
(C) = undefined; // Error
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/assignmentToVoidZero1.ts | TypeScript | // @filename: assignmentToVoidZero1.js
// @declaration: true
// @module: commonjs
// @outdir: auss
// @checkJs: true
// @allowJs: true
// #38552
exports.y = exports.x = void 0;
exports.x = 1;
exports.y = 2;
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/assignmentToVoidZero2.ts | TypeScript | // @filename: assignmentToVoidZero2.js
// @declaration: true
// @module: commonjs
// @outdir: auss
// @checkJs: true
// @allowJs: true
// @noImplicitAny: true
exports.j = 1;
exports.k = void 0;
var o = {}
o.x = 1
o.y = void 0
o.x + o.y
function C() {
this.p = 1
this.q = void 0
}
var c = new C()
c.p + c.q
// @filename: importer.js
import { j, k } from './assignmentToVoidZero2'
j + k
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/assignmentTypeNarrowing.ts | TypeScript | let x: string | number | boolean | RegExp;
x = "";
x; // string
[x] = [true];
x; // boolean
[x = ""] = [1];
x; // string | number
({x} = {x: true});
x; // boolean
({y: x} = {y: 1});
x; // number
({x = ""} = {x: true});
x; // string | boolean
({y: x = /a/} = {y: 1});
x; // number | RegExp
let a: string[];
for (x of a) {
x; // string
}
// Repro from #26405
type AOrArrA<T> = T | T[];
const arr: AOrArrA<{x?: "ok"}> = [{ x: "ok" }]; // weak type
arr.push({ x: "ok" });
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/assignments.ts | TypeScript | // In this file:
// Assign to a module
// Assign to a class
// Assign to an enum
// Assign to a function
// Assign to a variable
// Assign to a parameter
// Assign to an interface
module M { }
M = null; // Error
class C { }
C = null; // Error
enum E { A }
E = null; // Error
E.A = null; // OK per spec, Error per implementation (509581)
function fn() { }
fn = null; // Should be error
var v;
v = null; // OK
function fn2(p) {
p = null; // OK
}
interface I { }
I = null; // Error | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/asyncAliasReturnType_es5.ts | TypeScript | // @target: ES5
// @lib: es5,es2015.promise
// @noEmitHelpers: true
type PromiseAlias<T> = Promise<T>;
async function f(): PromiseAlias<void> {
} | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/asyncAliasReturnType_es6.ts | TypeScript | // @target: ES6
// @noEmitHelpers: true
type PromiseAlias<T> = Promise<T>;
async function f(): PromiseAlias<void> {
} | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/asyncArrowFunction10_es2017.ts | TypeScript | // @target: es2017
// @noEmitHelpers: true
var foo = async (): Promise<void> => {
// Legal to use 'await' in a type context.
var v: await;
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/asyncArrowFunction10_es5.ts | TypeScript | // @target: ES5
// @lib: es5,es2015.promise
// @noEmitHelpers: true
var foo = async (): Promise<void> => {
// Legal to use 'await' in a type context.
var v: await;
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/asyncArrowFunction10_es6.ts | TypeScript | // @target: ES6
// @noEmitHelpers: true
var foo = async (): Promise<void> => {
// Legal to use 'await' in a type context.
var v: await;
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/asyncArrowFunction11_es5.ts | TypeScript | // @target: es5
// @lib: esnext, dom
// @downlevelIteration: true
// https://github.com/Microsoft/TypeScript/issues/24722
class A {
b = async (...args: any[]) => {
await Promise.resolve();
const obj = { ["a"]: () => this }; // computed property name after `await` triggers case
};
} | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/asyncArrowFunction1_es2017.ts | TypeScript | // @target: es2017
// @noEmitHelpers: true
var foo = async (): Promise<void> => {
}; | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/asyncArrowFunction1_es5.ts | TypeScript | // @target: ES5
// @lib: es5,es2015.promise
// @noEmitHelpers: true
var foo = async (): Promise<void> => {
}; | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/asyncArrowFunction1_es6.ts | TypeScript | // @target: ES6
// @noEmitHelpers: true
var foo = async (): Promise<void> => {
}; | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/asyncArrowFunction2_es2017.ts | TypeScript | // @target: es2017
// @noEmitHelpers: true
var f = (await) => {
} | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/asyncArrowFunction2_es5.ts | TypeScript | // @target: ES5
// @lib: es5,es2015.promise
// @noEmitHelpers: true
var f = (await) => {
} | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/asyncArrowFunction2_es6.ts | TypeScript | // @target: ES6
// @noEmitHelpers: true
var f = (await) => {
} | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/asyncArrowFunction3_es2017.ts | TypeScript | // @target: es2017
// @noEmitHelpers: true
function f(await = await) {
} | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/asyncArrowFunction3_es5.ts | TypeScript | // @target: ES5
// @lib: es5,es2015.promise
// @noEmitHelpers: true
function f(await = await) {
} | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/asyncArrowFunction3_es6.ts | TypeScript | // @target: ES6
// @noEmitHelpers: true
function f(await = await) {
} | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/asyncArrowFunction4_es2017.ts | TypeScript | // @target: es2017
// @noEmitHelpers: true
var await = () => {
} | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/asyncArrowFunction4_es5.ts | TypeScript | // @target: ES5
// @lib: es5,es2015.promise
// @noEmitHelpers: true
var await = () => {
} | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/asyncArrowFunction4_es6.ts | TypeScript | // @target: ES6
// @noEmitHelpers: true
var await = () => {
} | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/asyncArrowFunctionCapturesArguments_es2017.ts | TypeScript | // @target: es2017
// @noEmitHelpers: true
class C {
method() {
function other() {}
var fn = async () => await other.apply(this, arguments);
}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/asyncArrowFunctionCapturesArguments_es5.ts | TypeScript | // @target: ES5
// @lib: es5,es2015.promise
// @noEmitHelpers: true
class C {
method() {
function other() {}
var fn = async () => await other.apply(this, arguments);
}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/asyncArrowFunctionCapturesArguments_es6.ts | TypeScript | // @target: ES6
// @noEmitHelpers: true
class C {
method() {
function other() {}
var fn = async () => await other.apply(this, arguments);
}
}
function f() {
return async () => async () => arguments.length;
} | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/asyncArrowFunctionCapturesThis_es2017.ts | TypeScript | // @target: es2017
// @noEmitHelpers: true
class C {
method() {
var fn = async () => await this;
}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/asyncArrowFunctionCapturesThis_es5.ts | TypeScript | // @target: ES5
// @lib: es5,es2015.promise
// @noEmitHelpers: true
class C {
method() {
var fn = async () => await this;
}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/asyncArrowFunctionCapturesThis_es6.ts | TypeScript | // @target: ES6
// @noEmitHelpers: true
class C {
method() {
var fn = async () => await this;
}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/asyncArrowFunction_allowJs.ts | TypeScript | // @allowJs: true
// @checkJs: true
// @noEmit: true
// @target: es2017
// @filename: file.js
// Error (good)
/** @type {function(): string} */
const a = () => 0
// Error (good)
/** @type {function(): string} */
const b = async () => 0
// No error (bad)
/** @type {function(): string} */
const c = async () => {
return 0
}
/** @type {function(function(): string): void} */
const f = (p) => {}
// Error (good)
f(async () => {
return 0
}) | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/asyncAwaitIsolatedModules_es2017.ts | TypeScript | // @target: es2017
// @isolatedModules: true
import { MyPromise } from "missing";
declare var p: Promise<number>;
declare var mp: MyPromise<number>;
async function f0() { }
async function f1(): Promise<void> { }
async function f3(): MyPromise<void> { }
let f4 = async function() { }
let f5 = async function(): Promise<void> { }
let f6 = async function(): MyPromise<void> { }
let f7 = async () => { };
let f8 = async (): Promise<void> => { };
let f9 = async (): MyPromise<void> => { };
let f10 = async () => p;
let f11 = async () => mp;
let f12 = async (): Promise<number> => mp;
let f13 = async (): MyPromise<number> => p;
let o = {
async m1() { },
async m2(): Promise<void> { },
async m3(): MyPromise<void> { }
};
class C {
async m1() { }
async m2(): Promise<void> { }
async m3(): MyPromise<void> { }
static async m4() { }
static async m5(): Promise<void> { }
static async m6(): MyPromise<void> { }
}
module M {
export async function f1() { }
} | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/asyncAwaitIsolatedModules_es5.ts | TypeScript | // @target: ES5
// @lib: es5,es2015.promise
// @isolatedModules: true
import { MyPromise } from "missing";
declare var p: Promise<number>;
declare var mp: MyPromise<number>;
async function f0() { }
async function f1(): Promise<void> { }
async function f3(): MyPromise<void> { }
let f4 = async function() { }
let f5 = async function(): Promise<void> { }
let f6 = async function(): MyPromise<void> { }
let f7 = async () => { };
let f8 = async (): Promise<void> => { };
let f9 = async (): MyPromise<void> => { };
let f10 = async () => p;
let f11 = async () => mp;
let f12 = async (): Promise<number> => mp;
let f13 = async (): MyPromise<number> => p;
let o = {
async m1() { },
async m2(): Promise<void> { },
async m3(): MyPromise<void> { }
};
class C {
async m1() { }
async m2(): Promise<void> { }
async m3(): MyPromise<void> { }
static async m4() { }
static async m5(): Promise<void> { }
static async m6(): MyPromise<void> { }
}
module M {
export async function f1() { }
} | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/asyncAwaitIsolatedModules_es6.ts | TypeScript | // @target: ES6
// @isolatedModules: true
import { MyPromise } from "missing";
declare var p: Promise<number>;
declare var mp: MyPromise<number>;
async function f0() { }
async function f1(): Promise<void> { }
async function f3(): MyPromise<void> { }
let f4 = async function() { }
let f5 = async function(): Promise<void> { }
let f6 = async function(): MyPromise<void> { }
let f7 = async () => { };
let f8 = async (): Promise<void> => { };
let f9 = async (): MyPromise<void> => { };
let f10 = async () => p;
let f11 = async () => mp;
let f12 = async (): Promise<number> => mp;
let f13 = async (): MyPromise<number> => p;
let o = {
async m1() { },
async m2(): Promise<void> { },
async m3(): MyPromise<void> { }
};
class C {
async m1() { }
async m2(): Promise<void> { }
async m3(): MyPromise<void> { }
static async m4() { }
static async m5(): Promise<void> { }
static async m6(): MyPromise<void> { }
}
module M {
export async function f1() { }
} | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/asyncAwaitNestedClasses_es5.ts | TypeScript | // @target: ES5
// @lib: es5,es2015.promise
// @noEmitHelpers: true
// https://github.com/Microsoft/TypeScript/issues/20744
class A {
static B = class B {
static func2(): Promise<void> {
return new Promise((resolve) => { resolve(null); });
}
static C = class C {
static async func() {
await B.func2();
}
}
}
}
A.B.C.func(); | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/asyncAwait_es2017.ts | TypeScript | // @target: es2017
type MyPromise<T> = Promise<T>;
declare var MyPromise: typeof Promise;
declare var p: Promise<number>;
declare var mp: MyPromise<number>;
async function f0() { }
async function f1(): Promise<void> { }
async function f3(): MyPromise<void> { }
let f4 = async function() { }
let f5 = async function(): Promise<void> { }
let f6 = async function(): MyPromise<void> { }
let f7 = async () => { };
let f8 = async (): Promise<void> => { };
let f9 = async (): MyPromise<void> => { };
let f10 = async () => p;
let f11 = async () => mp;
let f12 = async (): Promise<number> => mp;
let f13 = async (): MyPromise<number> => p;
let o = {
async m1() { },
async m2(): Promise<void> { },
async m3(): MyPromise<void> { }
};
class C {
async m1() { }
async m2(): Promise<void> { }
async m3(): MyPromise<void> { }
static async m4() { }
static async m5(): Promise<void> { }
static async m6(): MyPromise<void> { }
}
module M {
export async function f1() { }
}
async function f14() {
block: {
await 1;
break block;
}
} | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/asyncAwait_es5.ts | TypeScript | // @target: ES5
// @lib: es5,es2015.promise
type MyPromise<T> = Promise<T>;
declare var MyPromise: typeof Promise;
declare var p: Promise<number>;
declare var mp: MyPromise<number>;
async function f0() { }
async function f1(): Promise<void> { }
async function f3(): MyPromise<void> { }
let f4 = async function() { }
let f5 = async function(): Promise<void> { }
let f6 = async function(): MyPromise<void> { }
let f7 = async () => { };
let f8 = async (): Promise<void> => { };
let f9 = async (): MyPromise<void> => { };
let f10 = async () => p;
let f11 = async () => mp;
let f12 = async (): Promise<number> => mp;
let f13 = async (): MyPromise<number> => p;
let o = {
async m1() { },
async m2(): Promise<void> { },
async m3(): MyPromise<void> { }
};
class C {
async m1() { }
async m2(): Promise<void> { }
async m3(): MyPromise<void> { }
static async m4() { }
static async m5(): Promise<void> { }
static async m6(): MyPromise<void> { }
}
module M {
export async function f1() { }
}
async function f14() {
block: {
await 1;
break block;
}
} | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/asyncAwait_es6.ts | TypeScript | // @target: ES6
type MyPromise<T> = Promise<T>;
declare var MyPromise: typeof Promise;
declare var p: Promise<number>;
declare var mp: MyPromise<number>;
async function f0() { }
async function f1(): Promise<void> { }
async function f3(): MyPromise<void> { }
let f4 = async function() { }
let f5 = async function(): Promise<void> { }
let f6 = async function(): MyPromise<void> { }
let f7 = async () => { };
let f8 = async (): Promise<void> => { };
let f9 = async (): MyPromise<void> => { };
let f10 = async () => p;
let f11 = async () => mp;
let f12 = async (): Promise<number> => mp;
let f13 = async (): MyPromise<number> => p;
let o = {
async m1() { },
async m2(): Promise<void> { },
async m3(): MyPromise<void> { }
};
class C {
async m1() { }
async m2(): Promise<void> { }
async m3(): MyPromise<void> { }
static async m4() { }
static async m5(): Promise<void> { }
static async m6(): MyPromise<void> { }
}
module M {
export async function f1() { }
}
async function f14() {
block: {
await 1;
break block;
}
} | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/asyncFunctionDeclaration11_es2017.ts | TypeScript | // @target: es2017
// @noEmitHelpers: true
async function await(): Promise<void> {
} | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/asyncFunctionDeclaration11_es5.ts | TypeScript | // @target: ES5
// @lib: es5,es2015.promise
// @noEmitHelpers: true
async function await(): Promise<void> {
} | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/asyncFunctionDeclaration11_es6.ts | TypeScript | // @target: ES6
// @noEmitHelpers: true
async function await(): Promise<void> {
} | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/asyncFunctionDeclaration13_es2017.ts | TypeScript | // @target: es2017
// @noEmitHelpers: true
async function foo(): Promise<void> {
// Legal to use 'await' in a type context.
var v: await;
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/asyncFunctionDeclaration13_es5.ts | TypeScript | // @target: ES5
// @lib: es5,es2015.promise
// @noEmitHelpers: true
async function foo(): Promise<void> {
// Legal to use 'await' in a type context.
var v: await;
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/asyncFunctionDeclaration13_es6.ts | TypeScript | // @target: ES6
// @noEmitHelpers: true
async function foo(): Promise<void> {
// Legal to use 'await' in a type context.
var v: await;
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/asyncFunctionDeclaration14_es2017.ts | TypeScript | // @target: es2017
// @noEmitHelpers: true
async function foo(): Promise<void> {
return;
} | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/asyncFunctionDeclaration14_es5.ts | TypeScript | // @target: ES5
// @lib: es5,es2015.promise
// @noEmitHelpers: true
async function foo(): Promise<void> {
return;
} | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.