1/* 2* Copyright (c) Microsoft Corporation. All rights reserved. 3* Copyright (c) 2023 Huawei Device Co., Ltd. 4* Licensed under the Apache License, Version 2.0 (the "License"); 5* you may not use this file except in compliance with the License. 6* You may obtain a copy of the License at 7* 8* http://www.apache.org/licenses/LICENSE-2.0 9* 10* Unless required by applicable law or agreed to in writing, software 11* distributed under the License is distributed on an "AS IS" BASIS, 12* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13* See the License for the specific language governing permissions and 14* limitations under the License. 15* 16* This file has been modified by Huawei to verify type inference by adding verification statements. 17*/ 18 19// === tests/cases/conformance/es6/destructuring/destructuringWithLiteralInitializers.ts === 20declare function AssertType(value:any, type:string):void; 21// (arg: { x: any, y: any }) => void 22function f1({ x, y }) { } 23f1({ x: 1, y: 1 }); 24AssertType(f1({ x: 1, y: 1 }), "void"); 25AssertType(f1, "({ x: any; y: any; }) => void"); 26AssertType({ x: 1, y: 1 }, "{ x: number; y: number; }"); 27AssertType(x, "number"); 28AssertType(1, "int"); 29AssertType(y, "number"); 30AssertType(1, "int"); 31 32// (arg: { x: any, y?: number }) => void 33function f2({ x, y = 0 }) { } 34f2({ x: 1 }); 35AssertType(f2({ x: 1 }), "void"); 36AssertType(f2, "({ x: any; y?: number; }) => void"); 37AssertType({ x: 1 }, "{ x: number; }"); 38AssertType(x, "number"); 39AssertType(1, "int"); 40 41f2({ x: 1, y: 1 }); 42AssertType(f2({ x: 1, y: 1 }), "void"); 43AssertType(f2, "({ x: any; y?: number; }) => void"); 44AssertType({ x: 1, y: 1 }, "{ x: number; y: number; }"); 45AssertType(x, "number"); 46AssertType(1, "int"); 47AssertType(y, "number"); 48AssertType(1, "int"); 49 50// (arg: { x?: number, y?: number }) => void 51function f3({ x = 0, y = 0 }) { } 52f3({}); 53AssertType(f3({}), "void"); 54AssertType(f3, "({ x?: number; y?: number; }) => void"); 55AssertType({}, "{}"); 56 57f3({ x: 1 }); 58AssertType(f3({ x: 1 }), "void"); 59AssertType(f3, "({ x?: number; y?: number; }) => void"); 60AssertType({ x: 1 }, "{ x: number; }"); 61AssertType(x, "number"); 62AssertType(1, "int"); 63 64f3({ y: 1 }); 65AssertType(f3({ y: 1 }), "void"); 66AssertType(f3, "({ x?: number; y?: number; }) => void"); 67AssertType({ y: 1 }, "{ y: number; }"); 68AssertType(y, "number"); 69AssertType(1, "int"); 70 71f3({ x: 1, y: 1 }); 72AssertType(f3({ x: 1, y: 1 }), "void"); 73AssertType(f3, "({ x?: number; y?: number; }) => void"); 74AssertType({ x: 1, y: 1 }, "{ x: number; y: number; }"); 75AssertType(x, "number"); 76AssertType(1, "int"); 77AssertType(y, "number"); 78AssertType(1, "int"); 79 80// (arg?: { x: number, y: number }) => void 81function f4({ x, y } = { x: 0, y: 0 }) { } 82f4(); 83AssertType(f4(), "void"); 84AssertType(f4, "(?{ x: number; y: number; }) => void"); 85 86f4({ x: 1, y: 1 }); 87AssertType(f4({ x: 1, y: 1 }), "void"); 88AssertType(f4, "(?{ x: number; y: number; }) => void"); 89AssertType({ x: 1, y: 1 }, "{ x: number; y: number; }"); 90AssertType(x, "number"); 91AssertType(1, "int"); 92AssertType(y, "number"); 93AssertType(1, "int"); 94 95// (arg?: { x: number, y?: number }) => void 96function f5({ x, y = 0 } = { x: 0 }) { } 97f5(); 98AssertType(f5(), "void"); 99AssertType(f5, "(?{ x: number; y?: number; }) => void"); 100 101f5({ x: 1 }); 102AssertType(f5({ x: 1 }), "void"); 103AssertType(f5, "(?{ x: number; y?: number; }) => void"); 104AssertType({ x: 1 }, "{ x: number; }"); 105AssertType(x, "number"); 106AssertType(1, "int"); 107 108f5({ x: 1, y: 1 }); 109AssertType(f5({ x: 1, y: 1 }), "void"); 110AssertType(f5, "(?{ x: number; y?: number; }) => void"); 111AssertType({ x: 1, y: 1 }, "{ x: number; y: number; }"); 112AssertType(x, "number"); 113AssertType(1, "int"); 114AssertType(y, "number"); 115AssertType(1, "int"); 116 117// (arg?: { x?: number, y?: number }) => void 118function f6({ x = 0, y = 0 } = {}) { } 119f6(); 120AssertType(f6(), "void"); 121AssertType(f6, "(?{ x?: number; y?: number; }) => void"); 122 123f6({}); 124AssertType(f6({}), "void"); 125AssertType(f6, "(?{ x?: number; y?: number; }) => void"); 126AssertType({}, "{}"); 127 128f6({ x: 1 }); 129AssertType(f6({ x: 1 }), "void"); 130AssertType(f6, "(?{ x?: number; y?: number; }) => void"); 131AssertType({ x: 1 }, "{ x: number; }"); 132AssertType(x, "number"); 133AssertType(1, "int"); 134 135f6({ y: 1 }); 136AssertType(f6({ y: 1 }), "void"); 137AssertType(f6, "(?{ x?: number; y?: number; }) => void"); 138AssertType({ y: 1 }, "{ y: number; }"); 139AssertType(y, "number"); 140AssertType(1, "int"); 141 142f6({ x: 1, y: 1 }); 143AssertType(f6({ x: 1, y: 1 }), "void"); 144AssertType(f6, "(?{ x?: number; y?: number; }) => void"); 145AssertType({ x: 1, y: 1 }, "{ x: number; y: number; }"); 146AssertType(x, "number"); 147AssertType(1, "int"); 148AssertType(y, "number"); 149AssertType(1, "int"); 150 151// (arg?: { a: { x?: number, y?: number } }) => void 152function f7({ a: { x = 0, y = 0 } } = { a: {} }) { } 153f7(); 154AssertType(f7(), "void"); 155AssertType(f7, "(?{ a: { x?: number; y?: number; }; }) => void"); 156 157f7({ a: {} }); 158AssertType(f7({ a: {} }), "void"); 159AssertType(f7, "(?{ a: { x?: number; y?: number; }; }) => void"); 160AssertType({ a: {} }, "{ a: {}; }"); 161AssertType(a, "{}"); 162AssertType({}, "{}"); 163 164f7({ a: { x: 1 } }); 165AssertType(f7({ a: { x: 1 } }), "void"); 166AssertType(f7, "(?{ a: { x?: number; y?: number; }; }) => void"); 167AssertType({ a: { x: 1 } }, "{ a: { x: number; }; }"); 168AssertType(a, "{ x: number; }"); 169AssertType({ x: 1 }, "{ x: number; }"); 170AssertType(x, "number"); 171AssertType(1, "int"); 172 173f7({ a: { y: 1 } }); 174AssertType(f7({ a: { y: 1 } }), "void"); 175AssertType(f7, "(?{ a: { x?: number; y?: number; }; }) => void"); 176AssertType({ a: { y: 1 } }, "{ a: { y: number; }; }"); 177AssertType(a, "{ y: number; }"); 178AssertType({ y: 1 }, "{ y: number; }"); 179AssertType(y, "number"); 180AssertType(1, "int"); 181 182f7({ a: { x: 1, y: 1 } }); 183AssertType(f7({ a: { x: 1, y: 1 } }), "void"); 184AssertType(f7, "(?{ a: { x?: number; y?: number; }; }) => void"); 185AssertType({ a: { x: 1, y: 1 } }, "{ a: { x: number; y: number; }; }"); 186AssertType(a, "{ x: number; y: number; }"); 187AssertType({ x: 1, y: 1 }, "{ x: number; y: number; }"); 188AssertType(x, "number"); 189AssertType(1, "int"); 190AssertType(y, "number"); 191AssertType(1, "int"); 192 193// (arg: [any, any]) => void 194function g1([x, y]) { } 195g1([1, 1]); 196AssertType(g1([1, 1]), "void"); 197AssertType(g1, "([any, any]) => void"); 198AssertType([1, 1], "[number, number]"); 199AssertType(1, "int"); 200AssertType(1, "int"); 201 202// (arg: [number, number]) => void 203function g2([x = 0, y = 0]) { } 204g2([1, 1]); 205AssertType(g2([1, 1]), "void"); 206AssertType(g2, "([number?, number?]) => void"); 207AssertType([1, 1], "[number, number]"); 208AssertType(1, "int"); 209AssertType(1, "int"); 210 211// (arg?: [number, number]) => void 212function g3([x, y] = [0, 0]) { } 213g3(); 214AssertType(g3(), "void"); 215AssertType(g3, "(?[number, number]) => void"); 216 217g3([1, 1]); 218AssertType(g3([1, 1]), "void"); 219AssertType(g3, "(?[number, number]) => void"); 220AssertType([1, 1], "[number, number]"); 221AssertType(1, "int"); 222AssertType(1, "int"); 223 224// (arg?: [number, number]) => void 225function g4([x, y = 0] = [0]) { } 226g4(); 227AssertType(g4(), "void"); 228AssertType(g4, "(?[number, number?]) => void"); 229 230g4([1, 1]); 231AssertType(g4([1, 1]), "void"); 232AssertType(g4, "(?[number, number?]) => void"); 233AssertType([1, 1], "[number, number]"); 234AssertType(1, "int"); 235AssertType(1, "int"); 236 237// (arg?: [number, number]) => void 238function g5([x = 0, y = 0] = []) { } 239g5(); 240AssertType(g5(), "void"); 241AssertType(g5, "(?[number?, number?]) => void"); 242 243g5([1, 1]); 244AssertType(g5([1, 1]), "void"); 245AssertType(g5, "(?[number?, number?]) => void"); 246AssertType([1, 1], "[number, number]"); 247AssertType(1, "int"); 248AssertType(1, "int"); 249 250 251