0e905be42b
* Switch index signature storage to 'indexInfos: IndexInfo[]' property * Accept new baselines * Remove another usage of IndexKind enum * Update getIndexedAccessType and resolveMappedTypeMembers * Accept new baselines * Update grammar checking for index signatures * Accept new baselines * Consider all index signatures in mapped types and union types * Accept new baselines * Update getIndexType * Accept new baselines * Intersect multiple applicable index signatures * Use getApplicableIndexInfo instead of hardwired string/number handling * Update index signature relationship checking * Report type for which index signature is missing * Report type for which index signature is missing * Accept new baselines * Make 'number' index signatures consistently apply to numeric strings * Accept new baselines * Update fourslash test * Revise index constraint checking * Accept new baselines * Update error messages * Accept new baselines * Update type inference from index signatures * Update isKnownProperty * Update contextual typing based on index signatures * Accept new baselines * Support union types in index signature declarations * Accept new baselines * Check duplicate index signatures / remove redundant template literals from unions with string * Accept new baselines * Include key type in diagnostic / check symbol-named properties * Accept new baselines * Minor fix * Add tests * Accept new baselines * Add optimized findApplicableIndexInfoForName * Accept new baselines * Another place we don't need to obtain literal type for property name * Accept new baselines * Don't create literal types that are going to be discarded * Individual maps for string, number, bigint, and enum literal types * Remove ineffective optimizations * Accept new baselines * Permit intersections as key types in index signatures * Index expression in element access is template literal context * Add tests * Accept new baselines * Symbol index signatures from object literals with computed symbol properties * Accept new baselines * Add more tests * Accept new baselines * Implement Go To Definition for all applicable index signatures * Add fourslash test * Accept new API baselines
231 lines
5.8 KiB
Plaintext
231 lines
5.8 KiB
Plaintext
=== tests/cases/conformance/types/rest/objectRest.ts ===
|
|
var o = { a: 1, b: 'no' }
|
|
>o : { a: number; b: string; }
|
|
>{ a: 1, b: 'no' } : { a: number; b: string; }
|
|
>a : number
|
|
>1 : 1
|
|
>b : string
|
|
>'no' : "no"
|
|
|
|
var { ...clone } = o;
|
|
>clone : { a: number; b: string; }
|
|
>o : { a: number; b: string; }
|
|
|
|
var { a, ...justB } = o;
|
|
>a : number
|
|
>justB : { b: string; }
|
|
>o : { a: number; b: string; }
|
|
|
|
var { a, b: renamed, ...empty } = o;
|
|
>a : number
|
|
>b : any
|
|
>renamed : string
|
|
>empty : {}
|
|
>o : { a: number; b: string; }
|
|
|
|
var { ['b']: renamed, ...justA } = o;
|
|
>'b' : "b"
|
|
>renamed : string
|
|
>justA : { a: number; }
|
|
>o : { a: number; b: string; }
|
|
|
|
var { 'b': renamed, ...justA } = o;
|
|
>renamed : string
|
|
>justA : { a: number; }
|
|
>o : { a: number; b: string; }
|
|
|
|
var { b: { '0': n, '1': oooo }, ...justA } = o;
|
|
>b : any
|
|
>n : string
|
|
>oooo : string
|
|
>justA : { a: number; }
|
|
>o : { a: number; b: string; }
|
|
|
|
let o2 = { c: 'terrible idea?', d: 'yes' };
|
|
>o2 : { c: string; d: string; }
|
|
>{ c: 'terrible idea?', d: 'yes' } : { c: string; d: string; }
|
|
>c : string
|
|
>'terrible idea?' : "terrible idea?"
|
|
>d : string
|
|
>'yes' : "yes"
|
|
|
|
var { d: renamed, ...d } = o2;
|
|
>d : any
|
|
>renamed : string
|
|
>d : { c: string; }
|
|
>o2 : { c: string; d: string; }
|
|
|
|
let nestedrest: { x: number, n1: { y: number, n2: { z: number, n3: { n4: number } } }, rest: number, restrest: number };
|
|
>nestedrest : { x: number; n1: { y: number; n2: { z: number; n3: { n4: number; }; };}; rest: number; restrest: number; }
|
|
>x : number
|
|
>n1 : { y: number; n2: { z: number; n3: { n4: number; };}; }
|
|
>y : number
|
|
>n2 : { z: number; n3: { n4: number;}; }
|
|
>z : number
|
|
>n3 : { n4: number; }
|
|
>n4 : number
|
|
>rest : number
|
|
>restrest : number
|
|
|
|
var { x, n1: { y, n2: { z, n3: { ...nr } } }, ...restrest } = nestedrest;
|
|
>x : number
|
|
>n1 : any
|
|
>y : number
|
|
>n2 : any
|
|
>z : number
|
|
>n3 : any
|
|
>nr : { n4: number; }
|
|
>restrest : { rest: number; restrest: number; }
|
|
>nestedrest : { x: number; n1: { y: number; n2: { z: number; n3: { n4: number; }; }; }; rest: number; restrest: number; }
|
|
|
|
let complex: { x: { ka, ki }, y: number };
|
|
>complex : { x: { ka; ki;}; y: number; }
|
|
>x : { ka: any; ki: any; }
|
|
>ka : any
|
|
>ki : any
|
|
>y : number
|
|
|
|
var { x: { ka, ...nested }, y: other, ...rest } = complex;
|
|
>x : any
|
|
>ka : any
|
|
>nested : { ki: any; }
|
|
>y : any
|
|
>other : number
|
|
>rest : {}
|
|
>complex : { x: { ka: any; ki: any; }; y: number; }
|
|
|
|
({x: { ka, ...nested }, y: other, ...rest} = complex);
|
|
>({x: { ka, ...nested }, y: other, ...rest} = complex) : { x: { ka: any; ki: any; }; y: number; }
|
|
>{x: { ka, ...nested }, y: other, ...rest} = complex : { x: { ka: any; ki: any; }; y: number; }
|
|
>{x: { ka, ...nested }, y: other, ...rest} : { x: { ki: any; ka: any; }; y: number; }
|
|
>x : { ki: any; ka: any; }
|
|
>{ ka, ...nested } : { ki: any; ka: any; }
|
|
>ka : any
|
|
>nested : { ki: any; }
|
|
>y : number
|
|
>other : number
|
|
>rest : {}
|
|
>complex : { x: { ka: any; ki: any; }; y: number; }
|
|
|
|
var { x, ...fresh } = { x: 1, y: 2 };
|
|
>x : number
|
|
>fresh : { y: number; }
|
|
>{ x: 1, y: 2 } : { x: number; y: number; }
|
|
>x : number
|
|
>1 : 1
|
|
>y : number
|
|
>2 : 2
|
|
|
|
({ x, ...fresh } = { x: 1, y: 2 });
|
|
>({ x, ...fresh } = { x: 1, y: 2 }) : { x: number; y: number; }
|
|
>{ x, ...fresh } = { x: 1, y: 2 } : { x: number; y: number; }
|
|
>{ x, ...fresh } : { y: number; x: number; }
|
|
>x : number
|
|
>fresh : { y: number; }
|
|
>{ x: 1, y: 2 } : { x: number; y: number; }
|
|
>x : number
|
|
>1 : 1
|
|
>y : number
|
|
>2 : 2
|
|
|
|
class Removable {
|
|
>Removable : Removable
|
|
|
|
private x: number;
|
|
>x : number
|
|
|
|
protected y: number;
|
|
>y : number
|
|
|
|
set z(value: number) { }
|
|
>z : number
|
|
>value : number
|
|
|
|
get both(): number { return 12 }
|
|
>both : number
|
|
>12 : 12
|
|
|
|
set both(value: number) { }
|
|
>both : number
|
|
>value : number
|
|
|
|
m() { }
|
|
>m : () => void
|
|
|
|
removed: string;
|
|
>removed : string
|
|
|
|
remainder: string;
|
|
>remainder : string
|
|
}
|
|
interface I {
|
|
m(): void;
|
|
>m : () => void
|
|
|
|
removed: string;
|
|
>removed : string
|
|
|
|
remainder: string;
|
|
>remainder : string
|
|
}
|
|
var removable = new Removable();
|
|
>removable : Removable
|
|
>new Removable() : Removable
|
|
>Removable : typeof Removable
|
|
|
|
var { removed, ...removableRest } = removable;
|
|
>removed : string
|
|
>removableRest : { remainder: string; }
|
|
>removable : Removable
|
|
|
|
var i: I = removable;
|
|
>i : I
|
|
>removable : Removable
|
|
|
|
var { removed, ...removableRest2 } = i;
|
|
>removed : string
|
|
>removableRest2 : { m(): void; remainder: string; }
|
|
>i : I
|
|
|
|
let computed = 'b';
|
|
>computed : string
|
|
>'b' : "b"
|
|
|
|
let computed2 = 'a';
|
|
>computed2 : string
|
|
>'a' : "a"
|
|
|
|
var { [computed]: stillNotGreat, [computed2]: soSo, ...o } = o;
|
|
>computed : string
|
|
>stillNotGreat : any
|
|
>computed2 : string
|
|
>soSo : any
|
|
>o : { a: number; b: string; }
|
|
>o : { a: number; b: string; }
|
|
|
|
({ [computed]: stillNotGreat, [computed2]: soSo, ...o } = o);
|
|
>({ [computed]: stillNotGreat, [computed2]: soSo, ...o } = o) : { a: number; b: string; }
|
|
>{ [computed]: stillNotGreat, [computed2]: soSo, ...o } = o : { a: number; b: string; }
|
|
>{ [computed]: stillNotGreat, [computed2]: soSo, ...o } : { a: number; b: string; }
|
|
>[computed] : any
|
|
>computed : string
|
|
>stillNotGreat : any
|
|
>[computed2] : any
|
|
>computed2 : string
|
|
>soSo : any
|
|
>o : { a: number; b: string; }
|
|
>o : { a: number; b: string; }
|
|
|
|
var noContextualType = ({ aNumber = 12, ...notEmptyObject }) => aNumber + notEmptyObject.anythingGoes;
|
|
>noContextualType : ({ aNumber, ...notEmptyObject }: { [x: string]: any; aNumber?: number; }) => any
|
|
>({ aNumber = 12, ...notEmptyObject }) => aNumber + notEmptyObject.anythingGoes : ({ aNumber, ...notEmptyObject }: { [x: string]: any; aNumber?: number; }) => any
|
|
>aNumber : number
|
|
>12 : 12
|
|
>notEmptyObject : { [x: string]: any; }
|
|
>aNumber + notEmptyObject.anythingGoes : any
|
|
>aNumber : number
|
|
>notEmptyObject.anythingGoes : any
|
|
>notEmptyObject : { [x: string]: any; }
|
|
>anythingGoes : any
|
|
|