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/unicodeExtendedEscapesInRegularExpressions11_ES5.ts | TypeScript | // @target: es5
// ES6 Spec - 10.1.1 Static Semantics: UTF16Encoding (cp)
// 2. Let cu2 be ((cp – 65536) modulo 1024) + 0xDC00.
// Although we should just get back a single code point value of 0xDC00,
// this is a useful edge-case test.
var x = /\u{DC00}/g;
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/unicodeExtendedEscapesInRegularExpressions11_ES6.ts | TypeScript | // @target: es6
// ES6 Spec - 10.1.1 Static Semantics: UTF16Encoding (cp)
// 2. Let cu2 be ((cp – 65536) modulo 1024) + 0xDC00.
// Although we should just get back a single code point value of 0xDC00,
// this is a useful edge-case test.
var x = /\u{DC00}/g;
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/unicodeExtendedEscapesInRegularExpressions12_ES5.ts | TypeScript | // @target: es5
var x = /\u{FFFFFFFF}/g;
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/unicodeExtendedEscapesInRegularExpressions12_ES6.ts | TypeScript | // @target: es6
var x = /\u{FFFFFFFF}/g;
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/unicodeExtendedEscapesInRegularExpressions13_ES5.ts | TypeScript | // @target: es5
var x = /\u{DDDDD}/g;
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/unicodeExtendedEscapesInRegularExpressions13_ES6.ts | TypeScript | // @target: es6
var x = /\u{DDDDD}/g;
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/unicodeExtendedEscapesInRegularExpressions14_ES5.ts | TypeScript | // @target: es5
// Shouldn't work, negatives are not allowed.
var x = /\u{-DDDD}/g;
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/unicodeExtendedEscapesInRegularExpressions14_ES6.ts | TypeScript | // @target: es6
// Shouldn't work, negatives are not allowed.
var x = /\u{-DDDD}/g;
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/unicodeExtendedEscapesInRegularExpressions15_ES5.ts | TypeScript | // @target: es5
var x = /\u{abcd}\u{ef12}\u{3456}\u{7890}/g;
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/unicodeExtendedEscapesInRegularExpressions15_ES6.ts | TypeScript | // @target: es6
var x = /\u{abcd}\u{ef12}\u{3456}\u{7890}/g;
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/unicodeExtendedEscapesInRegularExpressions16_ES5.ts | TypeScript | // @target: es5
var x = /\u{ABCD}\u{EF12}\u{3456}\u{7890}/g;
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/unicodeExtendedEscapesInRegularExpressions16_ES6.ts | TypeScript | // @target: es6
var x = /\u{ABCD}\u{EF12}\u{3456}\u{7890}/g;
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/unicodeExtendedEscapesInRegularExpressions17_ES5.ts | TypeScript | // @target: es5
var x = /\u{r}\u{n}\u{t}/g;
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/unicodeExtendedEscapesInRegularExpressions17_ES6.ts | TypeScript | // @target: es6
var x = /\u{r}\u{n}\u{t}/g;
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/unicodeExtendedEscapesInRegularExpressions18_ES5.ts | TypeScript | // @target: es5
var x = /\u{65}\u{65}/g;
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/unicodeExtendedEscapesInRegularExpressions18_ES6.ts | TypeScript | // @target: es6
var x = /\u{65}\u{65}/g;
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/unicodeExtendedEscapesInRegularExpressions19_ES5.ts | TypeScript | // @target: es5
var x = /\u{}/g;
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/unicodeExtendedEscapesInRegularExpressions19_ES6.ts | TypeScript | // @target: es6
var x = /\u{}/g;
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/unicodeExtendedEscapesInStrings01_ES5.ts | TypeScript | // @target: es5
var x = "\u{0}";
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/unicodeExtendedEscapesInStrings01_ES6.ts | TypeScript | // @target: es6
var x = "\u{0}";
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/unicodeExtendedEscapesInStrings02_ES5.ts | TypeScript | // @target: es5
var x = "\u{00}";
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/unicodeExtendedEscapesInStrings02_ES6.ts | TypeScript | // @target: es6
var x = "\u{00}";
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/unicodeExtendedEscapesInStrings03_ES5.ts | TypeScript | // @target: es5
var x = "\u{0000}";
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/unicodeExtendedEscapesInStrings03_ES6.ts | TypeScript | // @target: es6
var x = "\u{0000}";
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/unicodeExtendedEscapesInStrings04_ES5.ts | TypeScript | // @target: es5
var x = "\u{00000000}";
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/unicodeExtendedEscapesInStrings04_ES6.ts | TypeScript | // @target: es6
var x = "\u{00000000}";
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/unicodeExtendedEscapesInStrings05_ES5.ts | TypeScript | // @target: es5
var x = "\u{48}\u{65}\u{6c}\u{6c}\u{6f}\u{20}\u{77}\u{6f}\u{72}\u{6c}\u{64}";
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/unicodeExtendedEscapesInStrings05_ES6.ts | TypeScript | // @target: es6
var x = "\u{48}\u{65}\u{6c}\u{6c}\u{6f}\u{20}\u{77}\u{6f}\u{72}\u{6c}\u{64}";
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/unicodeExtendedEscapesInStrings06_ES5.ts | TypeScript | // @target: es5
// ES6 Spec - 10.1.1 Static Semantics: UTF16Encoding (cp)
// 1. Assert: 0 ≤ cp ≤ 0x10FFFF.
var x = "\u{10FFFF}";
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/unicodeExtendedEscapesInStrings06_ES6.ts | TypeScript | // @target: es6
// ES6 Spec - 10.1.1 Static Semantics: UTF16Encoding (cp)
// 1. Assert: 0 ≤ cp ≤ 0x10FFFF.
var x = "\u{10FFFF}";
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/unicodeExtendedEscapesInStrings08_ES5.ts | TypeScript | // @target: es5
// ES6 Spec - 10.1.1 Static Semantics: UTF16Encoding (cp)
// 2. If cp ≤ 65535, return cp.
// (FFFF == 65535)
var x = "\u{FFFF}";
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/unicodeExtendedEscapesInStrings08_ES6.ts | TypeScript | // @target: es6
// ES6 Spec - 10.1.1 Static Semantics: UTF16Encoding (cp)
// 2. If cp ≤ 65535, return cp.
// (FFFF == 65535)
var x = "\u{FFFF}";
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/unicodeExtendedEscapesInStrings09_ES5.ts | TypeScript | // @target: es5
// ES6 Spec - 10.1.1 Static Semantics: UTF16Encoding (cp)
// 2. If cp ≤ 65535, return cp.
// (10000 == 65536)
var x = "\u{10000}";
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/unicodeExtendedEscapesInStrings09_ES6.ts | TypeScript | // @target: es6
// ES6 Spec - 10.1.1 Static Semantics: UTF16Encoding (cp)
// 2. If cp ≤ 65535, return cp.
// (10000 == 65536)
var x = "\u{10000}";
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/unicodeExtendedEscapesInStrings10_ES5.ts | TypeScript | // @target: es5
// ES6 Spec - 10.1.1 Static Semantics: UTF16Encoding (cp)
// 2. Let cu1 be floor((cp – 65536) / 1024) + 0xD800.
// Although we should just get back a single code point value of 0xD800,
// this is a useful edge-case test.
var x = "\u{D800}";
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/unicodeExtendedEscapesInStrings10_ES6.ts | TypeScript | // @target: es6
// ES6 Spec - 10.1.1 Static Semantics: UTF16Encoding (cp)
// 2. Let cu1 be floor((cp – 65536) / 1024) + 0xD800.
// Although we should just get back a single code point value of 0xD800,
// this is a useful edge-case test.
var x = "\u{D800}";
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/unicodeExtendedEscapesInStrings11_ES5.ts | TypeScript | // @target: es5
// ES6 Spec - 10.1.1 Static Semantics: UTF16Encoding (cp)
// 2. Let cu2 be ((cp – 65536) modulo 1024) + 0xDC00.
// Although we should just get back a single code point value of 0xDC00,
// this is a useful edge-case test.
var x = "\u{DC00}";
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/unicodeExtendedEscapesInStrings11_ES6.ts | TypeScript | // @target: es6
// ES6 Spec - 10.1.1 Static Semantics: UTF16Encoding (cp)
// 2. Let cu2 be ((cp – 65536) modulo 1024) + 0xDC00.
// Although we should just get back a single code point value of 0xDC00,
// this is a useful edge-case test.
var x = "\u{DC00}";
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/unicodeExtendedEscapesInStrings13_ES5.ts | TypeScript | // @target: es5
var x = "\u{DDDDD}";
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/unicodeExtendedEscapesInStrings13_ES6.ts | TypeScript | // @target: es6
var x = "\u{DDDDD}";
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/unicodeExtendedEscapesInStrings15_ES5.ts | TypeScript | // @target: es5
var x = "\u{abcd}\u{ef12}\u{3456}\u{7890}";
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/unicodeExtendedEscapesInStrings15_ES6.ts | TypeScript | // @target: es6
var x = "\u{abcd}\u{ef12}\u{3456}\u{7890}";
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/unicodeExtendedEscapesInStrings16_ES5.ts | TypeScript | // @target: es5
var x = "\u{ABCD}\u{EF12}\u{3456}\u{7890}";
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/unicodeExtendedEscapesInStrings16_ES6.ts | TypeScript | // @target: es6
var x = "\u{ABCD}\u{EF12}\u{3456}\u{7890}";
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/unicodeExtendedEscapesInStrings18_ES5.ts | TypeScript | // @target: es5
var x = "\u{65}\u{65}";
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/unicodeExtendedEscapesInStrings18_ES6.ts | TypeScript | // @target: es6
var x = "\u{65}\u{65}";
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/unicodeExtendedEscapesInStrings23_ES5.ts | TypeScript | // @target: es5
var x = "\u{00000000000067}";
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/unicodeExtendedEscapesInStrings23_ES6.ts | TypeScript | // @target: es6
var x = "\u{00000000000067}";
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/unicodeExtendedEscapesInTemplates01_ES5.ts | TypeScript | // @target: es5
var x = `\u{0}`;
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/unicodeExtendedEscapesInTemplates01_ES6.ts | TypeScript | // @target: es6
var x = `\u{0}`;
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/unicodeExtendedEscapesInTemplates02_ES5.ts | TypeScript | // @target: es5
var x = `\u{00}`;
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/unicodeExtendedEscapesInTemplates02_ES6.ts | TypeScript | // @target: es6
var x = `\u{00}`;
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/unicodeExtendedEscapesInTemplates03_ES5.ts | TypeScript | // @target: es5
var x = `\u{0000}`;
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/unicodeExtendedEscapesInTemplates03_ES6.ts | TypeScript | // @target: es6
var x = `\u{0000}`;
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/unicodeExtendedEscapesInTemplates04_ES5.ts | TypeScript | // @target: es5
var x = `\u{00000000}`;
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/unicodeExtendedEscapesInTemplates04_ES6.ts | TypeScript | // @target: es6
var x = `\u{00000000}`;
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/unicodeExtendedEscapesInTemplates05_ES5.ts | TypeScript | // @target: es5
var x = `\u{48}\u{65}\u{6c}\u{6c}\u{6f}\u{20}\u{77}\u{6f}\u{72}\u{6c}\u{64}`;
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/unicodeExtendedEscapesInTemplates05_ES6.ts | TypeScript | // @target: es6
var x = `\u{48}\u{65}\u{6c}\u{6c}\u{6f}\u{20}\u{77}\u{6f}\u{72}\u{6c}\u{64}`;
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/unicodeExtendedEscapesInTemplates06_ES5.ts | TypeScript | // @target: es5
// ES6 Spec - 10.1.1 Static Semantics: UTF16Encoding (cp)
// 1. Assert: 0 ≤ cp ≤ 0x10FFFF.
var x = `\u{10FFFF}`;
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/unicodeExtendedEscapesInTemplates06_ES6.ts | TypeScript | // @target: es6
// ES6 Spec - 10.1.1 Static Semantics: UTF16Encoding (cp)
// 1. Assert: 0 ≤ cp ≤ 0x10FFFF.
var x = `\u{10FFFF}`;
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/unicodeExtendedEscapesInTemplates08_ES5.ts | TypeScript | // @target: es5
// ES6 Spec - 10.1.1 Static Semantics: UTF16Encoding (cp)
// 2. If cp ≤ 65535, return cp.
// (FFFF == 65535)
var x = `\u{FFFF}`;
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/unicodeExtendedEscapesInTemplates08_ES6.ts | TypeScript | // @target: es6
// ES6 Spec - 10.1.1 Static Semantics: UTF16Encoding (cp)
// 2. If cp ≤ 65535, return cp.
// (FFFF == 65535)
var x = `\u{FFFF}`;
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/unicodeExtendedEscapesInTemplates09_ES5.ts | TypeScript | // @target: es5
// ES6 Spec - 10.1.1 Static Semantics: UTF16Encoding (cp)
// 2. If cp ≤ 65535, return cp.
// (10000 == 65536)
var x = `\u{10000}`;
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/unicodeExtendedEscapesInTemplates09_ES6.ts | TypeScript | // @target: es6
// ES6 Spec - 10.1.1 Static Semantics: UTF16Encoding (cp)
// 2. If cp ≤ 65535, return cp.
// (10000 == 65536)
var x = `\u{10000}`;
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/unicodeExtendedEscapesInTemplates10_ES5.ts | TypeScript | // @target: es5
// ES6 Spec - 10.1.1 Static Semantics: UTF16Encoding (cp)
// 2. Let cu1 be floor((cp – 65536) / 1024) + 0xD800.
// Although we should just get back a single code point value of 0xD800,
// this is a useful edge-case test.
var x = `\u{D800}`;
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/unicodeExtendedEscapesInTemplates10_ES6.ts | TypeScript | // @target: es6
// ES6 Spec - 10.1.1 Static Semantics: UTF16Encoding (cp)
// 2. Let cu1 be floor((cp – 65536) / 1024) + 0xD800.
// Although we should just get back a single code point value of 0xD800,
// this is a useful edge-case test.
var x = `\u{D800}`;
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/unicodeExtendedEscapesInTemplates11_ES5.ts | TypeScript | // @target: es5
// ES6 Spec - 10.1.1 Static Semantics: UTF16Encoding (cp)
// 2. Let cu2 be ((cp – 65536) modulo 1024) + 0xDC00.
// Although we should just get back a single code point value of 0xDC00,
// this is a useful edge-case test.
var x = `\u{DC00}`;
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/unicodeExtendedEscapesInTemplates11_ES6.ts | TypeScript | // @target: es6
// ES6 Spec - 10.1.1 Static Semantics: UTF16Encoding (cp)
// 2. Let cu2 be ((cp – 65536) modulo 1024) + 0xDC00.
// Although we should just get back a single code point value of 0xDC00,
// this is a useful edge-case test.
var x = `\u{DC00}`;
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/unicodeExtendedEscapesInTemplates13_ES5.ts | TypeScript | // @target: es5
var x = `\u{DDDDD}`;
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/unicodeExtendedEscapesInTemplates13_ES6.ts | TypeScript | // @target: es6
var x = `\u{DDDDD}`;
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/unicodeExtendedEscapesInTemplates15_ES5.ts | TypeScript | // @target: es5
var x = `\u{abcd}\u{ef12}\u{3456}\u{7890}`;
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/unicodeExtendedEscapesInTemplates15_ES6.ts | TypeScript | // @target: es6
var x = `\u{abcd}\u{ef12}\u{3456}\u{7890}`;
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/unicodeExtendedEscapesInTemplates16_ES5.ts | TypeScript | // @target: es5
var x = `\u{ABCD}\u{EF12}\u{3456}\u{7890}`;
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/unicodeExtendedEscapesInTemplates16_ES6.ts | TypeScript | // @target: es6
var x = `\u{ABCD}\u{EF12}\u{3456}\u{7890}`;
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/unicodeExtendedEscapesInTemplates18_ES5.ts | TypeScript | // @target: es5
var x = `\u{65}\u{65}`;
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/unicodeExtendedEscapesInTemplates18_ES6.ts | TypeScript | // @target: es6
var x = `\u{65}\u{65}`;
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/unicodeExtendedEscapesInTemplates20_ES5.ts | TypeScript | // @target: es5
var x = `\u{48}\u{65}\u{6c}\u{6c}\u{6f}${`\u{20}\u{020}\u{0020}\u{000020}`}\u{77}\u{6f}\u{72}\u{6c}\u{64}`;
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/unicodeExtendedEscapesInTemplates20_ES6.ts | TypeScript | // @target: es6
var x = `\u{48}\u{65}\u{6c}\u{6c}\u{6f}${`\u{20}\u{020}\u{0020}\u{000020}`}\u{77}\u{6f}\u{72}\u{6c}\u{64}`;
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/unionAndIntersectionInference1.ts | TypeScript | // @target: es2015
// Repro from #2264
interface Y { 'i am a very certain type': Y }
var y: Y = <Y>undefined;
function destructure<a, r>(
something: a | Y,
haveValue: (value: a) => r,
haveY: (value: Y) => r
): r {
return something === y ? haveY(y) : haveValue(<a>something);
}
var value = Math.random(... | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/unionAndIntersectionInference2.ts | TypeScript | declare function f1<T>(x: T | string): T;
var a1: string;
var b1: string | string[];
var c1: string[] | string;
var d1: string | { name: string };
var e1: number | string | boolean;
f1(a1); // string
f1(b1); // string[]
f1(c1); // string[]
f1(d1); // { name: string }
f1(e1); // number | boolean
declare function f2<T>... | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/unionAndIntersectionInference3.ts | TypeScript | // @strict: true
// @target: esnext
// Repro from #30720
type Maybe<T> = T | undefined;
declare function concatMaybe<T>(...args: (Maybe<T> | Maybe<T>[])[]): T[];
concatMaybe([1, 2, 3], 4);
// Repros from #32247
const g: <U, R, S>(com: () => Iterator<S, U, R> | AsyncIterator<S, U, R>) => Promise<U> = async <U, R, S>... | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/unionSubtypeIfEveryConstituentTypeIsSubtype.ts | TypeScript | enum e {
e1,
e2
}
// A union type U is a subtype of a type T if each type in U is a subtype of T
interface I {
[x: string]: any;
foo: string | number; // ok
foo2: e | number; // ok
}
interface I2 {
[x: string]: number;
// S is union type and each constituent type of S is a subtype of T
... | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/unionThisTypeInFunctions.ts | TypeScript | interface Real {
method(this: this, n: number): void;
data: string;
}
interface Fake {
method(this: this, n: number): void;
data: number;
}
function test(r: Real | Fake) {
r.method(12); // error
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/unionTypeCallSignatures.ts | TypeScript | var numOrDate: number | Date;
var strOrBoolean: string | boolean;
var strOrNum: string | number;
// If each type in U has call signatures and the sets of call signatures are identical ignoring return types,
// U has the same set of call signatures, but with return types that are unions of the return types of the res... | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/unionTypeCallSignatures2.ts | TypeScript | interface A {
(x: number): number;
(x: string, y?: string): boolean;
(x: Date): void;
<T>(x: T[]): T[];
}
interface B {
(x: number): number;
(x: string): string;
(x: Date): void;
<T>(x: T[]): T[];
}
interface C {
(x: string, ...y: string[]): number;
(x: number, s?: string): nu... | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/unionTypeCallSignatures3.ts | TypeScript | function f1(s: string) { }
function f2(s?: string) { }
function f3(...s: string[]) { }
function f4(s: string, s2?: string) { }
function f5(s?: string, n?: number) { }
function f6(s?: string, ...n: number[]) { }
function f7(s: string, ...sRest: string[]) { }
var fUnion: typeof f1 | typeof f2 | typeof f3 | typeof f4 | ... | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/unionTypeCallSignatures4.ts | TypeScript | type F1 = (a: string, b?: string) => void;
type F2 = (a: string, b?: string, c?: string) => void;
type F3 = (a: string, ...rest: string[]) => void;
type F4 = (a: string, b?: string, ...rest: string[]) => void;
type F5 = (a: string, b: string) => void;
var f12: F1 | F2;
f12("a");
f12("a", "b");
f12("a", "b", "c"); //... | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/unionTypeCallSignatures5.ts | TypeScript | // #31485
interface A {
(this: void, b?: number): void;
}
interface B {
(this: number, b?: number): void;
}
interface C {
(i: number): void;
}
declare const fn: A | B | C;
fn(0);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/unionTypeCallSignatures6.ts | TypeScript | type A = { a: string };
type B = { b: number };
type C = { c: string };
type D = { d: number };
type F0 = () => void;
// #31547
type F1 = (this: A) => void;
type F2 = (this: B) => void;
declare var f1: F1 | F2;
f1(); // error
declare var f2: F0 | F1;
f2(); // error
interface F3 {
(this: A): void;
(this: B): void;... | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/unionTypeCallSignatures7.ts | TypeScript | // @strict: true
// @noEmit: true
// https://github.com/microsoft/TypeScript/issues/55203
interface Callable<Name extends string> {
(): `${Name} without id`;
(id: number): `${Name} with id`;
}
declare const f: Callable<"A"> | Callable<"B">;
const result = f(123);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/unionTypeConstructSignatures.ts | TypeScript | var numOrDate: number | Date;
var strOrBoolean: string | boolean;
var strOrNum: string | number;
// If each type in U has construct signatures and the sets of construct signatures are identical ignoring return types,
// U has the same set of construct signatures, but with return types that are unions of the return ty... | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/unionTypeEquivalence.ts | TypeScript | // A | B is equivalent to A if B is a subtype of A
class C { }
class D extends C { foo() { } }
var x: C;
var x : C | D;
// A | B is equivalent to B | A.
var y: string | number;
var y : number | string;
// AB | C is equivalent to A | BC, where AB is A | B and BC is B | C.
var z : string | number | boolean;
var z : (s... | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/unionTypeFromArrayLiteral.ts | TypeScript | // The resulting type an array literal expression is determined as follows:
// If the array literal is empty, the resulting type is an array type with the element type Undefined.
// Otherwise, if the array literal is contextually typed by a type that has a property with the numeric name ‘0’, the resulting type is a tu... | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/unionTypeIdentity.ts | TypeScript | // Two types are considered identical when
// they are union types with identical sets of constituent types, or
var strOrNum: string | boolean;
var strOrNum: boolean | string;
var strOrNum: boolean | string | boolean;
var strOrNum: string; // error
var strOrNum: boolean; // error
var strOrNum: number; // error | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/unionTypeIndexSignature.ts | TypeScript | var numOrDate: number | Date;
var anyVar: number;
// If each type in U has a string index signature,
// U has a string index signature of a union type of the types of the string index signatures from each type in U.
var unionOfDifferentReturnType: { [a: string]: number; } | { [a: string]: Date; };
numOrDate = union... | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/unionTypeInference.ts | TypeScript | // @strict: true
// @target: esnext
declare const b: boolean;
declare const s: string;
declare const sn: string | number;
declare function f1<T>(x: T, y: string | T): T;
const a1 = f1(1, 2); // 1 | 2
const a2 = f1(1, "hello"); // 1
const a3 = f1(1, sn); // number
const a4 = f1(undefined, "abc"); // undefined
con... | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/unionTypeLiterals.ts | TypeScript | // basic valid forms of union literals
var simpleUnion: string | number;
var unionOfUnion: string | number | boolean;
var arrayOfUnions: (string | number)[];
var arrayOfUnions: Array<string | number>;
var unionOfFunctionType: (() => string) | (() => number);
var unionOfFunctionType: { (): string } | { (): number };
... | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/unionTypeMembers.ts | TypeScript | interface I1<T> {
commonMethodType(a: string): string;
commonPropertyType: string;
commonMethodDifferentParameterType(a: string): string;
commonMethodDifferentReturnType(a: string): string;
commonPropertyDifferenType: string;
commonMethodWithTypeParameter(a: T): T;
commonMethodWithOwnType... | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/unionTypePropertyAccessibility.ts | TypeScript | class Default {
member: string;
}
class Public {
public member: string;
}
class Protected {
protected member: string;
}
class Private {
private member: number;
}
var v1: Default;
var v2: Public;
var v3: Protected;
var v4: Private;
var v5: Default | Public;
var v6: Default | Protected;
var v7: Defaul... | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/tsc/unionTypeReadonly.ts | TypeScript | interface Base {
readonly value: number;
}
interface Identical {
readonly value: number;
}
interface Mutable {
value: number;
}
interface DifferentType {
readonly value: string;
}
interface DifferentName {
readonly other: number;
}
let base: Base;
base.value = 12 // error, lhs can't be a readonly pr... | 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.